2 import * as version from './version.mjs';
4 const imports: any = {};
7 var js_objs: Array<WeakRef<object>> = [];
8 var js_invoke: Function;
9 var getRandomValues: Function;
11 imports.wasi_snapshot_preview1 = {
12 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
13 // This should generally only be used to print panic messages
14 console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
15 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
16 for (var i = 0; i < iovec_array_len; i++) {
17 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
18 console.log(String.fromCharCode(...bytes_view));
22 "fd_close": (_fd: number) => {
23 // This is not generally called, but may be referenced in debug builds
24 console.log("wasi_snapshot_preview1:fd_close");
25 return 58; // Not Supported
27 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
28 // This is not generally called, but may be referenced in debug builds
29 console.log("wasi_snapshot_preview1:fd_seek");
30 return 58; // Not Supported
32 "random_get": (buf_ptr: number, buf_len: number) => {
33 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
37 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
38 // This is called before fd_write to format + print panic messages
39 console.log("wasi_snapshot_preview1:environ_sizes_get");
40 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
41 out_count_view[0] = 0;
42 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
46 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
47 // This is called before fd_write to format + print panic messages
48 console.log("wasi_snapshot_preview1:environ_get");
49 return 58; // Note supported - we said there were 0 environment entries!
52 console.log("wasi_snapshot_preview1:proc_exit");
57 let isWasmInitialized: boolean = false;
59 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
60 if (typeof crypto === "undefined") {
61 var crypto_import = (await import('crypto')).webcrypto;
62 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
64 getRandomValues = crypto.getRandomValues.bind(crypto);
67 wasm = wasmInstance.exports;
68 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
69 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
72 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
73 throw new Error("Compiled LDK library and LDK class failes do not match");
74 // Fetching the LDK versions from C also checks that the header and binaries match
75 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
76 const ldk_ver: number = wasm.TS_get_ldk_version();
77 if (c_bindings_ver == 0)
78 throw new Error("LDK version did not match the header we built against");
80 throw new Error("LDK C bindings version did not match the header we built against");
81 const c_bindings_version: string = decodeString(c_bindings_ver)
82 const ldk_version: string = decodeString(ldk_ver);
83 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
85 isWasmInitialized = true;
89 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
90 imports.env["js_invoke_function"] = js_invoke;
91 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
92 await finishInitializeWasm(wasmInstance);
96 export async function initializeWasmFetch(uri: string) {
97 const stream = fetch(uri);
98 imports.env["js_invoke_function"] = js_invoke;
99 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
100 await finishInitializeWasm(wasmInstance);
104 const nextMultipleOfFour = (value: number) => {
105 return Math.ceil(value / 4) * 4;
109 export function encodeUint8Array (inputArray: Uint8Array): number {
110 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
111 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
112 arrayLengthView[0] = inputArray.length;
113 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
114 arrayMemoryView.set(inputArray);
115 return cArrayPointer;
118 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
119 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
120 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
121 arrayMemoryView.set(inputArray, 1);
122 arrayMemoryView[0] = inputArray.length;
123 return cArrayPointer;
126 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
127 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
128 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
129 arrayLengthView[0] = inputArray.length;
130 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
131 arrayMemoryView.set(inputArray);
132 return cArrayPointer;
136 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
137 if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
142 export function getArrayLength(arrayPointer: number): number {
143 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
144 return arraySizeViewer[0];
147 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
148 const arraySize = getArrayLength(arrayPointer);
149 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
150 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
151 // will free the underlying memory when it becomes unreachable instead of copying here.
152 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
153 const actualArray = actualArrayViewer.slice(0, arraySize);
155 wasm.TS_free(arrayPointer);
159 const decodeUint32Array = (arrayPointer: number, free = true) => {
160 const arraySize = getArrayLength(arrayPointer);
161 const actualArrayViewer = new Uint32Array(
162 wasm.memory.buffer, // value
163 arrayPointer + 4, // offset (ignoring length bytes)
164 arraySize // uint32 count
166 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
167 // will free the underlying memory when it becomes unreachable instead of copying here.
168 const actualArray = actualArrayViewer.slice(0, arraySize);
170 wasm.TS_free(arrayPointer);
176 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
179 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
180 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
181 return actualArrayViewer[idx];
185 export function encodeString(str: string): number {
186 const charArray = new TextEncoder().encode(str);
187 return encodeUint8Array(charArray);
191 export function decodeString(stringPointer: number, free = true): string {
192 const arraySize = getArrayLength(stringPointer);
193 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
194 const result = new TextDecoder("utf-8").decode(memoryView);
197 wasm.TS_free(stringPointer);
203 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
204 /* @internal */ export function debugPrintRemainingAllocs() { }
207 export enum AccessError {
209 * The requested chain is unknown.
211 LDKAccessError_UnknownChain,
213 * The requested transaction doesn't exist or hasn't confirmed.
215 LDKAccessError_UnknownTx,
220 export enum COption_NoneZ {
222 * When we're in this state, this COption_NoneZ contains a
224 LDKCOption_NoneZ_Some,
226 * When we're in this state, this COption_NoneZ contains nothing
228 LDKCOption_NoneZ_None,
233 export enum ChannelMonitorUpdateErr {
235 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
236 our state failed, but is expected to succeed at some point in the future).
238 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
239 submitting new commitment transactions to the counterparty. Once the update(s) that failed
240 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
241 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
244 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
245 you return a TemporaryFailure you must ensure that it is written to disk safely before
246 writing out the latest ChannelManager state.
248 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
249 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
250 to claim it on this channel) and those updates must be applied wherever they can be. At
251 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
252 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
253 the channel which would invalidate previous ChannelMonitors are not made when a channel has
256 Note that even if updates made after TemporaryFailure succeed you must still provide a
257 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
258 normal channel operation. Note that this is normally generated through a call to
259 [`ChainMonitor::channel_monitor_updated`].
261 Note that the update being processed here will not be replayed for you when you return a
262 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
263 you must store the update itself on your own local disk prior to returning a
264 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
265 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
268 For deployments where a copy of ChannelMonitors and other local state are backed up in a
269 remote location (with local copies persisted immediately), it is anticipated that all
270 updates will return TemporaryFailure until the remote copies could be updated.
272 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
274 LDKChannelMonitorUpdateErr_TemporaryFailure,
276 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
277 different watchtower and cannot update with all watchtowers that were previously informed
280 At reception of this error, ChannelManager will force-close the channel and return at
281 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
282 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
283 update must be rejected.
285 This failure may also signal a failure to update the local persisted copy of one of
286 the channel monitor instance.
288 Note that even when you fail a holder commitment transaction update, you must store the
289 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
290 broadcasts it (e.g distributed channel-monitor deployment)
292 In case of distributed watchtowers deployment, the new version must be written to disk, as
293 state may have been stored but rejected due to a block forcing a commitment broadcast. This
294 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
295 lagging behind on block processing.
297 LDKChannelMonitorUpdateErr_PermanentFailure,
302 export enum ConfirmationTarget {
304 * We are happy with this transaction confirming slowly when feerate drops some.
306 LDKConfirmationTarget_Background,
308 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
310 LDKConfirmationTarget_Normal,
312 * We'd like this transaction to confirm in the next few blocks.
314 LDKConfirmationTarget_HighPriority,
321 * Designates extremely verbose information, including gossip-induced messages
325 * Designates very low priority, often extremely verbose, information
329 * Designates lower priority information
333 * Designates useful information
337 * Designates hazardous situations
341 * Designates very serious errors
348 export enum Network {
350 * The main Bitcoin blockchain.
354 * The testnet3 blockchain.
358 * A local test blockchain.
362 * A blockchain on which blocks are signed instead of mined.
369 export enum Secp256k1Error {
371 * Signature failed verification
373 LDKSecp256k1Error_IncorrectSignature,
375 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
377 LDKSecp256k1Error_InvalidMessage,
381 LDKSecp256k1Error_InvalidPublicKey,
385 LDKSecp256k1Error_InvalidSignature,
389 LDKSecp256k1Error_InvalidSecretKey,
393 LDKSecp256k1Error_InvalidRecoveryId,
395 * Invalid tweak for add_assign or mul_assign
397 LDKSecp256k1Error_InvalidTweak,
399 * tweak_add_check failed on an xonly public key
401 LDKSecp256k1Error_TweakCheckFailed,
403 * Didn't pass enough memory to context creation with preallocated memory
405 LDKSecp256k1Error_NotEnoughMemory,
408 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
410 export function TxOut_get_script_pubkey(thing: number): number {
411 if(!isWasmInitialized) {
412 throw new Error("initializeWasm() must be awaited first!");
414 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
415 return nativeResponseValue;
417 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
419 export function TxOut_get_value(thing: number): bigint {
420 if(!isWasmInitialized) {
421 throw new Error("initializeWasm() must be awaited first!");
423 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
424 return nativeResponseValue;
426 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
428 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
429 if(!isWasmInitialized) {
430 throw new Error("initializeWasm() must be awaited first!");
432 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
433 return nativeResponseValue;
435 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
437 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
438 if(!isWasmInitialized) {
439 throw new Error("initializeWasm() must be awaited first!");
441 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
442 return nativeResponseValue;
444 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
446 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
447 if(!isWasmInitialized) {
448 throw new Error("initializeWasm() must be awaited first!");
450 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
451 return nativeResponseValue;
453 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
455 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
456 if(!isWasmInitialized) {
457 throw new Error("initializeWasm() must be awaited first!");
459 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
460 return nativeResponseValue;
462 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
464 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
465 if(!isWasmInitialized) {
466 throw new Error("initializeWasm() must be awaited first!");
468 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
469 return nativeResponseValue;
471 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
473 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
474 if(!isWasmInitialized) {
475 throw new Error("initializeWasm() must be awaited first!");
477 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
478 return nativeResponseValue;
480 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
482 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
483 if(!isWasmInitialized) {
484 throw new Error("initializeWasm() must be awaited first!");
486 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
487 return nativeResponseValue;
489 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
491 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
492 if(!isWasmInitialized) {
493 throw new Error("initializeWasm() must be awaited first!");
495 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
496 return nativeResponseValue;
498 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
500 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
501 if(!isWasmInitialized) {
502 throw new Error("initializeWasm() must be awaited first!");
504 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
505 return nativeResponseValue;
507 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
509 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
510 if(!isWasmInitialized) {
511 throw new Error("initializeWasm() must be awaited first!");
513 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
514 return nativeResponseValue;
516 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
518 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
519 if(!isWasmInitialized) {
520 throw new Error("initializeWasm() must be awaited first!");
522 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
523 return nativeResponseValue;
525 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
527 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
528 if(!isWasmInitialized) {
529 throw new Error("initializeWasm() must be awaited first!");
531 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
532 return nativeResponseValue;
534 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
536 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
537 if(!isWasmInitialized) {
538 throw new Error("initializeWasm() must be awaited first!");
540 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
541 return nativeResponseValue;
543 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
545 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
546 if(!isWasmInitialized) {
547 throw new Error("initializeWasm() must be awaited first!");
549 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
550 return nativeResponseValue;
553 export class LDKCOption_u32Z {
554 protected constructor() {}
557 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
558 if(!isWasmInitialized) {
559 throw new Error("initializeWasm() must be awaited first!");
561 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
562 return nativeResponseValue;
565 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
566 if(!isWasmInitialized) {
567 throw new Error("initializeWasm() must be awaited first!");
569 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
570 return nativeResponseValue;
572 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
574 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
575 if(!isWasmInitialized) {
576 throw new Error("initializeWasm() must be awaited first!");
578 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
579 return nativeResponseValue;
581 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
583 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
584 if(!isWasmInitialized) {
585 throw new Error("initializeWasm() must be awaited first!");
587 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
588 return nativeResponseValue;
590 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
592 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
593 if(!isWasmInitialized) {
594 throw new Error("initializeWasm() must be awaited first!");
596 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
597 return nativeResponseValue;
599 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
601 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
602 if(!isWasmInitialized) {
603 throw new Error("initializeWasm() must be awaited first!");
605 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
606 return nativeResponseValue;
608 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
610 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
611 if(!isWasmInitialized) {
612 throw new Error("initializeWasm() must be awaited first!");
614 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
615 return nativeResponseValue;
617 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
619 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
620 if(!isWasmInitialized) {
621 throw new Error("initializeWasm() must be awaited first!");
623 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
624 return nativeResponseValue;
626 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
628 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
629 if(!isWasmInitialized) {
630 throw new Error("initializeWasm() must be awaited first!");
632 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
633 return nativeResponseValue;
635 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
637 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
638 if(!isWasmInitialized) {
639 throw new Error("initializeWasm() must be awaited first!");
641 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
642 return nativeResponseValue;
644 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
646 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
647 if(!isWasmInitialized) {
648 throw new Error("initializeWasm() must be awaited first!");
650 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
651 return nativeResponseValue;
653 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
655 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
656 if(!isWasmInitialized) {
657 throw new Error("initializeWasm() must be awaited first!");
659 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
660 return nativeResponseValue;
662 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
664 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
665 if(!isWasmInitialized) {
666 throw new Error("initializeWasm() must be awaited first!");
668 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
669 return nativeResponseValue;
671 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
673 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
674 if(!isWasmInitialized) {
675 throw new Error("initializeWasm() must be awaited first!");
677 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
678 // debug statements here
680 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
682 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
683 if(!isWasmInitialized) {
684 throw new Error("initializeWasm() must be awaited first!");
686 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
687 return nativeResponseValue;
689 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
691 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
692 if(!isWasmInitialized) {
693 throw new Error("initializeWasm() must be awaited first!");
695 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
696 return nativeResponseValue;
698 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
700 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
701 if(!isWasmInitialized) {
702 throw new Error("initializeWasm() must be awaited first!");
704 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
705 return nativeResponseValue;
707 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
709 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
710 if(!isWasmInitialized) {
711 throw new Error("initializeWasm() must be awaited first!");
713 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
714 // debug statements here
716 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
718 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
719 if(!isWasmInitialized) {
720 throw new Error("initializeWasm() must be awaited first!");
722 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
723 return nativeResponseValue;
725 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
727 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
728 if(!isWasmInitialized) {
729 throw new Error("initializeWasm() must be awaited first!");
731 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
732 // debug statements here
734 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
736 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
737 if(!isWasmInitialized) {
738 throw new Error("initializeWasm() must be awaited first!");
740 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
741 return nativeResponseValue;
743 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
745 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
746 if(!isWasmInitialized) {
747 throw new Error("initializeWasm() must be awaited first!");
749 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
750 return nativeResponseValue;
752 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
754 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
755 if(!isWasmInitialized) {
756 throw new Error("initializeWasm() must be awaited first!");
758 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
759 return nativeResponseValue;
761 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
763 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
764 if(!isWasmInitialized) {
765 throw new Error("initializeWasm() must be awaited first!");
767 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
768 return nativeResponseValue;
771 export interface LDKType {
773 debug_str (): number;
778 export function LDKType_new(impl: LDKType): number {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 var new_obj_idx = js_objs.length;
783 for (var i = 0; i < js_objs.length; i++) {
784 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
786 js_objs[i] = new WeakRef(impl);
787 return wasm.TS_LDKType_new(i);
789 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
791 export function Type_type_id(this_arg: number): number {
792 if(!isWasmInitialized) {
793 throw new Error("initializeWasm() must be awaited first!");
795 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
796 return nativeResponseValue;
798 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
800 export function Type_debug_str(this_arg: number): number {
801 if(!isWasmInitialized) {
802 throw new Error("initializeWasm() must be awaited first!");
804 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
805 return nativeResponseValue;
807 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
809 export function Type_write(this_arg: number): number {
810 if(!isWasmInitialized) {
811 throw new Error("initializeWasm() must be awaited first!");
813 const nativeResponseValue = wasm.TS_Type_write(this_arg);
814 return nativeResponseValue;
817 export class LDKCOption_TypeZ {
818 protected constructor() {}
821 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
822 if(!isWasmInitialized) {
823 throw new Error("initializeWasm() must be awaited first!");
825 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
826 return nativeResponseValue;
829 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
830 if(!isWasmInitialized) {
831 throw new Error("initializeWasm() must be awaited first!");
833 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
834 return nativeResponseValue;
836 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
838 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
839 if(!isWasmInitialized) {
840 throw new Error("initializeWasm() must be awaited first!");
842 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
843 return nativeResponseValue;
845 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
847 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
848 if(!isWasmInitialized) {
849 throw new Error("initializeWasm() must be awaited first!");
851 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
852 return nativeResponseValue;
854 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
856 export function CResult_StringErrorZ_get_ok(owner: number): number {
857 if(!isWasmInitialized) {
858 throw new Error("initializeWasm() must be awaited first!");
860 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
861 return nativeResponseValue;
863 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
865 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
866 if(!isWasmInitialized) {
867 throw new Error("initializeWasm() must be awaited first!");
869 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
870 return nativeResponseValue;
872 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
874 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
875 if(!isWasmInitialized) {
876 throw new Error("initializeWasm() must be awaited first!");
878 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
879 return nativeResponseValue;
881 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
883 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
884 if(!isWasmInitialized) {
885 throw new Error("initializeWasm() must be awaited first!");
887 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
888 return nativeResponseValue;
891 export class LDKMonitorEvent {
892 protected constructor() {}
895 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
896 if(!isWasmInitialized) {
897 throw new Error("initializeWasm() must be awaited first!");
899 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
900 return nativeResponseValue;
903 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
904 if(!isWasmInitialized) {
905 throw new Error("initializeWasm() must be awaited first!");
907 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
908 return nativeResponseValue;
911 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
912 if(!isWasmInitialized) {
913 throw new Error("initializeWasm() must be awaited first!");
915 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
916 return nativeResponseValue;
919 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
920 if(!isWasmInitialized) {
921 throw new Error("initializeWasm() must be awaited first!");
923 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
924 return nativeResponseValue;
927 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
928 if(!isWasmInitialized) {
929 throw new Error("initializeWasm() must be awaited first!");
931 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
932 return nativeResponseValue;
935 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
936 if(!isWasmInitialized) {
937 throw new Error("initializeWasm() must be awaited first!");
939 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
940 return nativeResponseValue;
943 export class LDKCOption_MonitorEventZ {
944 protected constructor() {}
947 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
948 if(!isWasmInitialized) {
949 throw new Error("initializeWasm() must be awaited first!");
951 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
952 return nativeResponseValue;
955 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
956 if(!isWasmInitialized) {
957 throw new Error("initializeWasm() must be awaited first!");
959 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
960 return nativeResponseValue;
962 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
964 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
965 if(!isWasmInitialized) {
966 throw new Error("initializeWasm() must be awaited first!");
968 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
969 return nativeResponseValue;
971 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
973 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
974 if(!isWasmInitialized) {
975 throw new Error("initializeWasm() must be awaited first!");
977 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
978 return nativeResponseValue;
980 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
982 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
983 if(!isWasmInitialized) {
984 throw new Error("initializeWasm() must be awaited first!");
986 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
987 return nativeResponseValue;
989 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
991 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
992 if(!isWasmInitialized) {
993 throw new Error("initializeWasm() must be awaited first!");
995 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
996 return nativeResponseValue;
998 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1000 export function CResult_NoneNoneZ_get_ok(owner: number): void {
1001 if(!isWasmInitialized) {
1002 throw new Error("initializeWasm() must be awaited first!");
1004 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
1005 // debug statements here
1007 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
1009 export function CResult_NoneNoneZ_get_err(owner: number): void {
1010 if(!isWasmInitialized) {
1011 throw new Error("initializeWasm() must be awaited first!");
1013 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
1014 // debug statements here
1016 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
1018 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
1019 if(!isWasmInitialized) {
1020 throw new Error("initializeWasm() must be awaited first!");
1022 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
1023 return nativeResponseValue;
1025 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
1027 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
1028 if(!isWasmInitialized) {
1029 throw new Error("initializeWasm() must be awaited first!");
1031 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
1032 return nativeResponseValue;
1034 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
1036 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
1037 if(!isWasmInitialized) {
1038 throw new Error("initializeWasm() must be awaited first!");
1040 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
1041 return nativeResponseValue;
1043 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
1045 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
1046 if(!isWasmInitialized) {
1047 throw new Error("initializeWasm() must be awaited first!");
1049 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
1050 return nativeResponseValue;
1052 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
1054 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
1055 if(!isWasmInitialized) {
1056 throw new Error("initializeWasm() must be awaited first!");
1058 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
1059 return nativeResponseValue;
1061 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
1063 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
1064 if(!isWasmInitialized) {
1065 throw new Error("initializeWasm() must be awaited first!");
1067 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
1068 return nativeResponseValue;
1071 export class LDKPaymentPurpose {
1072 protected constructor() {}
1075 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1076 if(!isWasmInitialized) {
1077 throw new Error("initializeWasm() must be awaited first!");
1079 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1080 return nativeResponseValue;
1083 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1084 if(!isWasmInitialized) {
1085 throw new Error("initializeWasm() must be awaited first!");
1087 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1088 return nativeResponseValue;
1091 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1092 if(!isWasmInitialized) {
1093 throw new Error("initializeWasm() must be awaited first!");
1095 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1096 return nativeResponseValue;
1099 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1100 if(!isWasmInitialized) {
1101 throw new Error("initializeWasm() must be awaited first!");
1103 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1104 return nativeResponseValue;
1107 export class LDKCOption_u64Z {
1108 protected constructor() {}
1111 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1112 if(!isWasmInitialized) {
1113 throw new Error("initializeWasm() must be awaited first!");
1115 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1116 return nativeResponseValue;
1119 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1120 if(!isWasmInitialized) {
1121 throw new Error("initializeWasm() must be awaited first!");
1123 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1124 return nativeResponseValue;
1127 export class LDKNetworkUpdate {
1128 protected constructor() {}
1131 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1132 if(!isWasmInitialized) {
1133 throw new Error("initializeWasm() must be awaited first!");
1135 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1136 return nativeResponseValue;
1139 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1140 if(!isWasmInitialized) {
1141 throw new Error("initializeWasm() must be awaited first!");
1143 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1144 return nativeResponseValue;
1147 export function LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr: number): bigint {
1148 if(!isWasmInitialized) {
1149 throw new Error("initializeWasm() must be awaited first!");
1151 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr);
1152 return nativeResponseValue;
1155 export function LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr: number): boolean {
1156 if(!isWasmInitialized) {
1157 throw new Error("initializeWasm() must be awaited first!");
1159 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr);
1160 return nativeResponseValue;
1163 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1164 if(!isWasmInitialized) {
1165 throw new Error("initializeWasm() must be awaited first!");
1167 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1168 return nativeResponseValue;
1171 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1172 if(!isWasmInitialized) {
1173 throw new Error("initializeWasm() must be awaited first!");
1175 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1176 return nativeResponseValue;
1179 export class LDKCOption_NetworkUpdateZ {
1180 protected constructor() {}
1183 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1184 if(!isWasmInitialized) {
1185 throw new Error("initializeWasm() must be awaited first!");
1187 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1188 return nativeResponseValue;
1191 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1192 if(!isWasmInitialized) {
1193 throw new Error("initializeWasm() must be awaited first!");
1195 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1196 return nativeResponseValue;
1199 export class LDKSpendableOutputDescriptor {
1200 protected constructor() {}
1203 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1204 if(!isWasmInitialized) {
1205 throw new Error("initializeWasm() must be awaited first!");
1207 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1208 return nativeResponseValue;
1211 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1212 if(!isWasmInitialized) {
1213 throw new Error("initializeWasm() must be awaited first!");
1215 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1216 return nativeResponseValue;
1219 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1220 if(!isWasmInitialized) {
1221 throw new Error("initializeWasm() must be awaited first!");
1223 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1224 return nativeResponseValue;
1227 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1228 if(!isWasmInitialized) {
1229 throw new Error("initializeWasm() must be awaited first!");
1231 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1232 return nativeResponseValue;
1235 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1236 if(!isWasmInitialized) {
1237 throw new Error("initializeWasm() must be awaited first!");
1239 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1240 return nativeResponseValue;
1243 export class LDKClosureReason {
1244 protected constructor() {}
1247 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1248 if(!isWasmInitialized) {
1249 throw new Error("initializeWasm() must be awaited first!");
1251 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1252 return nativeResponseValue;
1255 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1256 if(!isWasmInitialized) {
1257 throw new Error("initializeWasm() must be awaited first!");
1259 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1260 return nativeResponseValue;
1263 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1264 if(!isWasmInitialized) {
1265 throw new Error("initializeWasm() must be awaited first!");
1267 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1268 return nativeResponseValue;
1271 export class LDKEvent {
1272 protected constructor() {}
1275 export function LDKEvent_ty_from_ptr(ptr: number): number {
1276 if(!isWasmInitialized) {
1277 throw new Error("initializeWasm() must be awaited first!");
1279 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1280 return nativeResponseValue;
1283 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1284 if(!isWasmInitialized) {
1285 throw new Error("initializeWasm() must be awaited first!");
1287 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1288 return nativeResponseValue;
1291 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1292 if(!isWasmInitialized) {
1293 throw new Error("initializeWasm() must be awaited first!");
1295 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1296 return nativeResponseValue;
1299 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1300 if(!isWasmInitialized) {
1301 throw new Error("initializeWasm() must be awaited first!");
1303 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1304 return nativeResponseValue;
1307 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1308 if(!isWasmInitialized) {
1309 throw new Error("initializeWasm() must be awaited first!");
1311 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1312 return nativeResponseValue;
1315 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1316 if(!isWasmInitialized) {
1317 throw new Error("initializeWasm() must be awaited first!");
1319 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1320 return nativeResponseValue;
1323 export function LDKEvent_PaymentReceived_get_amt(ptr: number): bigint {
1324 if(!isWasmInitialized) {
1325 throw new Error("initializeWasm() must be awaited first!");
1327 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amt(ptr);
1328 return nativeResponseValue;
1331 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1332 if(!isWasmInitialized) {
1333 throw new Error("initializeWasm() must be awaited first!");
1335 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1336 return nativeResponseValue;
1339 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1340 if(!isWasmInitialized) {
1341 throw new Error("initializeWasm() must be awaited first!");
1343 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1344 return nativeResponseValue;
1347 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1348 if(!isWasmInitialized) {
1349 throw new Error("initializeWasm() must be awaited first!");
1351 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1352 return nativeResponseValue;
1355 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1356 if(!isWasmInitialized) {
1357 throw new Error("initializeWasm() must be awaited first!");
1359 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1360 return nativeResponseValue;
1363 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1364 if(!isWasmInitialized) {
1365 throw new Error("initializeWasm() must be awaited first!");
1367 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1368 return nativeResponseValue;
1371 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1372 if(!isWasmInitialized) {
1373 throw new Error("initializeWasm() must be awaited first!");
1375 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1376 return nativeResponseValue;
1379 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1380 if(!isWasmInitialized) {
1381 throw new Error("initializeWasm() must be awaited first!");
1383 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1384 return nativeResponseValue;
1387 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1388 if(!isWasmInitialized) {
1389 throw new Error("initializeWasm() must be awaited first!");
1391 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1392 return nativeResponseValue;
1395 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1396 if(!isWasmInitialized) {
1397 throw new Error("initializeWasm() must be awaited first!");
1399 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1400 return nativeResponseValue;
1403 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1404 if(!isWasmInitialized) {
1405 throw new Error("initializeWasm() must be awaited first!");
1407 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1408 return nativeResponseValue;
1411 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1412 if(!isWasmInitialized) {
1413 throw new Error("initializeWasm() must be awaited first!");
1415 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1416 return nativeResponseValue;
1419 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1420 if(!isWasmInitialized) {
1421 throw new Error("initializeWasm() must be awaited first!");
1423 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1424 return nativeResponseValue;
1427 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1428 if(!isWasmInitialized) {
1429 throw new Error("initializeWasm() must be awaited first!");
1431 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1432 return nativeResponseValue;
1435 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1436 if(!isWasmInitialized) {
1437 throw new Error("initializeWasm() must be awaited first!");
1439 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1440 return nativeResponseValue;
1443 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1444 if(!isWasmInitialized) {
1445 throw new Error("initializeWasm() must be awaited first!");
1447 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1448 return nativeResponseValue;
1451 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1452 if(!isWasmInitialized) {
1453 throw new Error("initializeWasm() must be awaited first!");
1455 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1456 return nativeResponseValue;
1459 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1460 if(!isWasmInitialized) {
1461 throw new Error("initializeWasm() must be awaited first!");
1463 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1464 return nativeResponseValue;
1467 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1468 if(!isWasmInitialized) {
1469 throw new Error("initializeWasm() must be awaited first!");
1471 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1472 return nativeResponseValue;
1475 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1476 if(!isWasmInitialized) {
1477 throw new Error("initializeWasm() must be awaited first!");
1479 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1480 return nativeResponseValue;
1483 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1484 if(!isWasmInitialized) {
1485 throw new Error("initializeWasm() must be awaited first!");
1487 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1488 return nativeResponseValue;
1491 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1492 if(!isWasmInitialized) {
1493 throw new Error("initializeWasm() must be awaited first!");
1495 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1496 return nativeResponseValue;
1499 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1500 if(!isWasmInitialized) {
1501 throw new Error("initializeWasm() must be awaited first!");
1503 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1504 return nativeResponseValue;
1507 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1508 if(!isWasmInitialized) {
1509 throw new Error("initializeWasm() must be awaited first!");
1511 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1512 return nativeResponseValue;
1515 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1516 if(!isWasmInitialized) {
1517 throw new Error("initializeWasm() must be awaited first!");
1519 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1520 return nativeResponseValue;
1523 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1524 if(!isWasmInitialized) {
1525 throw new Error("initializeWasm() must be awaited first!");
1527 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1528 return nativeResponseValue;
1531 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1532 if(!isWasmInitialized) {
1533 throw new Error("initializeWasm() must be awaited first!");
1535 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1536 return nativeResponseValue;
1539 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1540 if(!isWasmInitialized) {
1541 throw new Error("initializeWasm() must be awaited first!");
1543 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1544 return nativeResponseValue;
1546 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1548 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
1549 if(!isWasmInitialized) {
1550 throw new Error("initializeWasm() must be awaited first!");
1552 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
1553 return nativeResponseValue;
1555 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1557 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
1558 if(!isWasmInitialized) {
1559 throw new Error("initializeWasm() must be awaited first!");
1561 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
1562 return nativeResponseValue;
1564 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
1566 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
1567 if(!isWasmInitialized) {
1568 throw new Error("initializeWasm() must be awaited first!");
1570 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
1571 return nativeResponseValue;
1573 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
1575 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
1576 if(!isWasmInitialized) {
1577 throw new Error("initializeWasm() must be awaited first!");
1579 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
1580 return nativeResponseValue;
1582 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
1584 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
1585 if(!isWasmInitialized) {
1586 throw new Error("initializeWasm() must be awaited first!");
1588 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
1589 return nativeResponseValue;
1591 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
1593 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
1594 if(!isWasmInitialized) {
1595 throw new Error("initializeWasm() must be awaited first!");
1597 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
1598 return nativeResponseValue;
1601 export class LDKBalance {
1602 protected constructor() {}
1605 export function LDKBalance_ty_from_ptr(ptr: number): number {
1606 if(!isWasmInitialized) {
1607 throw new Error("initializeWasm() must be awaited first!");
1609 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
1610 return nativeResponseValue;
1613 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
1614 if(!isWasmInitialized) {
1615 throw new Error("initializeWasm() must be awaited first!");
1617 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
1618 return nativeResponseValue;
1621 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
1622 if(!isWasmInitialized) {
1623 throw new Error("initializeWasm() must be awaited first!");
1625 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
1626 return nativeResponseValue;
1629 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
1630 if(!isWasmInitialized) {
1631 throw new Error("initializeWasm() must be awaited first!");
1633 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
1634 return nativeResponseValue;
1637 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
1638 if(!isWasmInitialized) {
1639 throw new Error("initializeWasm() must be awaited first!");
1641 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
1642 return nativeResponseValue;
1645 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
1646 if(!isWasmInitialized) {
1647 throw new Error("initializeWasm() must be awaited first!");
1649 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
1650 return nativeResponseValue;
1653 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
1654 if(!isWasmInitialized) {
1655 throw new Error("initializeWasm() must be awaited first!");
1657 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
1658 return nativeResponseValue;
1661 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
1662 if(!isWasmInitialized) {
1663 throw new Error("initializeWasm() must be awaited first!");
1665 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
1666 return nativeResponseValue;
1668 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
1670 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
1671 if(!isWasmInitialized) {
1672 throw new Error("initializeWasm() must be awaited first!");
1674 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
1675 return nativeResponseValue;
1677 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
1679 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
1680 if(!isWasmInitialized) {
1681 throw new Error("initializeWasm() must be awaited first!");
1683 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
1684 return nativeResponseValue;
1686 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
1688 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
1689 if(!isWasmInitialized) {
1690 throw new Error("initializeWasm() must be awaited first!");
1692 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
1693 return nativeResponseValue;
1695 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
1697 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
1698 if(!isWasmInitialized) {
1699 throw new Error("initializeWasm() must be awaited first!");
1701 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
1702 // debug statements here
1704 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
1706 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
1707 if(!isWasmInitialized) {
1708 throw new Error("initializeWasm() must be awaited first!");
1710 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
1711 return nativeResponseValue;
1713 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
1715 export function CResult_SignatureNoneZ_get_err(owner: number): void {
1716 if(!isWasmInitialized) {
1717 throw new Error("initializeWasm() must be awaited first!");
1719 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
1720 // debug statements here
1723 export interface LDKBaseSign {
1724 get_per_commitment_point (idx: bigint): number;
1725 release_commitment_secret (idx: bigint): number;
1726 validate_holder_commitment (holder_tx: number): number;
1727 channel_keys_id (): number;
1728 sign_counterparty_commitment (commitment_tx: number): number;
1729 validate_counterparty_revocation (idx: bigint, secret: number): number;
1730 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
1731 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
1732 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
1733 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
1734 sign_closing_transaction (closing_tx: number): number;
1735 sign_channel_announcement (msg: number): number;
1736 ready_channel (channel_parameters: number): void;
1740 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
1741 if(!isWasmInitialized) {
1742 throw new Error("initializeWasm() must be awaited first!");
1744 var new_obj_idx = js_objs.length;
1745 for (var i = 0; i < js_objs.length; i++) {
1746 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1748 js_objs[i] = new WeakRef(impl);
1749 return wasm.TS_LDKBaseSign_new(i);
1751 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
1753 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
1754 if(!isWasmInitialized) {
1755 throw new Error("initializeWasm() must be awaited first!");
1757 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
1758 return nativeResponseValue;
1760 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
1762 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
1763 if(!isWasmInitialized) {
1764 throw new Error("initializeWasm() must be awaited first!");
1766 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
1767 return nativeResponseValue;
1769 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx
1771 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number): number {
1772 if(!isWasmInitialized) {
1773 throw new Error("initializeWasm() must be awaited first!");
1775 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx);
1776 return nativeResponseValue;
1778 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
1780 export function BaseSign_channel_keys_id(this_arg: number): number {
1781 if(!isWasmInitialized) {
1782 throw new Error("initializeWasm() must be awaited first!");
1784 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
1785 return nativeResponseValue;
1787 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx
1789 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number {
1790 if(!isWasmInitialized) {
1791 throw new Error("initializeWasm() must be awaited first!");
1793 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx);
1794 return nativeResponseValue;
1796 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
1798 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
1799 if(!isWasmInitialized) {
1800 throw new Error("initializeWasm() must be awaited first!");
1802 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
1803 return nativeResponseValue;
1805 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
1807 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
1808 if(!isWasmInitialized) {
1809 throw new Error("initializeWasm() must be awaited first!");
1811 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
1812 return nativeResponseValue;
1814 // LDKCResult_SignatureNoneZ BaseSign_sign_justice_revoked_output LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]
1816 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
1817 if(!isWasmInitialized) {
1818 throw new Error("initializeWasm() must be awaited first!");
1820 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
1821 return nativeResponseValue;
1823 // LDKCResult_SignatureNoneZ BaseSign_sign_justice_revoked_htlc LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
1825 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
1826 if(!isWasmInitialized) {
1827 throw new Error("initializeWasm() must be awaited first!");
1829 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
1830 return nativeResponseValue;
1832 // LDKCResult_SignatureNoneZ BaseSign_sign_counterparty_htlc_transaction LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
1834 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
1835 if(!isWasmInitialized) {
1836 throw new Error("initializeWasm() must be awaited first!");
1838 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
1839 return nativeResponseValue;
1841 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
1843 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
1844 if(!isWasmInitialized) {
1845 throw new Error("initializeWasm() must be awaited first!");
1847 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
1848 return nativeResponseValue;
1850 // LDKCResult_SignatureNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
1852 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
1853 if(!isWasmInitialized) {
1854 throw new Error("initializeWasm() must be awaited first!");
1856 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
1857 return nativeResponseValue;
1859 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
1861 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
1862 if(!isWasmInitialized) {
1863 throw new Error("initializeWasm() must be awaited first!");
1865 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
1866 // debug statements here
1868 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
1870 export function BaseSign_get_pubkeys(this_arg: number): number {
1871 if(!isWasmInitialized) {
1872 throw new Error("initializeWasm() must be awaited first!");
1874 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
1875 return nativeResponseValue;
1878 export interface LDKSign {
1883 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
1884 if(!isWasmInitialized) {
1885 throw new Error("initializeWasm() must be awaited first!");
1887 var new_obj_idx = js_objs.length;
1888 for (var i = 0; i < js_objs.length; i++) {
1889 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1891 js_objs[i] = new WeakRef(impl);
1892 return wasm.TS_LDKSign_new(i);
1894 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
1896 export function Sign_write(this_arg: number): number {
1897 if(!isWasmInitialized) {
1898 throw new Error("initializeWasm() must be awaited first!");
1900 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
1901 return nativeResponseValue;
1903 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
1905 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
1906 if(!isWasmInitialized) {
1907 throw new Error("initializeWasm() must be awaited first!");
1909 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
1910 return nativeResponseValue;
1912 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
1914 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
1915 if(!isWasmInitialized) {
1916 throw new Error("initializeWasm() must be awaited first!");
1918 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
1919 return nativeResponseValue;
1921 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
1923 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
1924 if(!isWasmInitialized) {
1925 throw new Error("initializeWasm() must be awaited first!");
1927 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
1928 return nativeResponseValue;
1930 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
1932 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
1933 if(!isWasmInitialized) {
1934 throw new Error("initializeWasm() must be awaited first!");
1936 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
1937 return nativeResponseValue;
1939 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1941 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1946 return nativeResponseValue;
1948 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1950 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1951 if(!isWasmInitialized) {
1952 throw new Error("initializeWasm() must be awaited first!");
1954 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1955 return nativeResponseValue;
1957 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1959 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1960 if(!isWasmInitialized) {
1961 throw new Error("initializeWasm() must be awaited first!");
1963 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1964 return nativeResponseValue;
1966 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1968 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1973 return nativeResponseValue;
1975 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1977 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1978 if(!isWasmInitialized) {
1979 throw new Error("initializeWasm() must be awaited first!");
1981 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1982 return nativeResponseValue;
1984 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1986 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1987 if(!isWasmInitialized) {
1988 throw new Error("initializeWasm() must be awaited first!");
1990 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1991 return nativeResponseValue;
1993 // struct LDKPayee CResult_PayeeDecodeErrorZ_get_ok(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR owner);
1995 export function CResult_PayeeDecodeErrorZ_get_ok(owner: number): number {
1996 if(!isWasmInitialized) {
1997 throw new Error("initializeWasm() must be awaited first!");
1999 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_get_ok(owner);
2000 return nativeResponseValue;
2002 // struct LDKDecodeError CResult_PayeeDecodeErrorZ_get_err(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR owner);
2004 export function CResult_PayeeDecodeErrorZ_get_err(owner: number): number {
2005 if(!isWasmInitialized) {
2006 throw new Error("initializeWasm() must be awaited first!");
2008 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_get_err(owner);
2009 return nativeResponseValue;
2011 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2013 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
2014 if(!isWasmInitialized) {
2015 throw new Error("initializeWasm() must be awaited first!");
2017 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2018 return nativeResponseValue;
2020 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2022 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
2023 if(!isWasmInitialized) {
2024 throw new Error("initializeWasm() must be awaited first!");
2026 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2027 return nativeResponseValue;
2029 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2031 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
2032 if(!isWasmInitialized) {
2033 throw new Error("initializeWasm() must be awaited first!");
2035 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2036 return nativeResponseValue;
2038 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2040 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
2041 if(!isWasmInitialized) {
2042 throw new Error("initializeWasm() must be awaited first!");
2044 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2045 return nativeResponseValue;
2047 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2049 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
2050 if(!isWasmInitialized) {
2051 throw new Error("initializeWasm() must be awaited first!");
2053 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2054 return nativeResponseValue;
2056 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2058 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
2059 if(!isWasmInitialized) {
2060 throw new Error("initializeWasm() must be awaited first!");
2062 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2063 return nativeResponseValue;
2065 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2067 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2068 if(!isWasmInitialized) {
2069 throw new Error("initializeWasm() must be awaited first!");
2071 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2072 // debug statements here
2074 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2076 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2077 if(!isWasmInitialized) {
2078 throw new Error("initializeWasm() must be awaited first!");
2080 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2081 return nativeResponseValue;
2083 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
2085 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
2086 if(!isWasmInitialized) {
2087 throw new Error("initializeWasm() must be awaited first!");
2089 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
2090 return nativeResponseValue;
2092 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
2094 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
2095 if(!isWasmInitialized) {
2096 throw new Error("initializeWasm() must be awaited first!");
2098 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
2099 return nativeResponseValue;
2102 export class LDKErrorAction {
2103 protected constructor() {}
2106 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
2107 if(!isWasmInitialized) {
2108 throw new Error("initializeWasm() must be awaited first!");
2110 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
2111 return nativeResponseValue;
2114 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
2115 if(!isWasmInitialized) {
2116 throw new Error("initializeWasm() must be awaited first!");
2118 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2119 return nativeResponseValue;
2122 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
2123 if(!isWasmInitialized) {
2124 throw new Error("initializeWasm() must be awaited first!");
2126 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2127 return nativeResponseValue;
2130 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
2131 if(!isWasmInitialized) {
2132 throw new Error("initializeWasm() must be awaited first!");
2134 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2135 return nativeResponseValue;
2138 export class LDKMessageSendEvent {
2139 protected constructor() {}
2142 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
2143 if(!isWasmInitialized) {
2144 throw new Error("initializeWasm() must be awaited first!");
2146 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2147 return nativeResponseValue;
2150 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
2151 if(!isWasmInitialized) {
2152 throw new Error("initializeWasm() must be awaited first!");
2154 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2155 return nativeResponseValue;
2158 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
2159 if(!isWasmInitialized) {
2160 throw new Error("initializeWasm() must be awaited first!");
2162 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2163 return nativeResponseValue;
2166 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
2167 if(!isWasmInitialized) {
2168 throw new Error("initializeWasm() must be awaited first!");
2170 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2171 return nativeResponseValue;
2174 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
2175 if(!isWasmInitialized) {
2176 throw new Error("initializeWasm() must be awaited first!");
2178 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2179 return nativeResponseValue;
2182 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
2183 if(!isWasmInitialized) {
2184 throw new Error("initializeWasm() must be awaited first!");
2186 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2187 return nativeResponseValue;
2190 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
2191 if(!isWasmInitialized) {
2192 throw new Error("initializeWasm() must be awaited first!");
2194 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2195 return nativeResponseValue;
2198 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
2199 if(!isWasmInitialized) {
2200 throw new Error("initializeWasm() must be awaited first!");
2202 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2203 return nativeResponseValue;
2206 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
2207 if(!isWasmInitialized) {
2208 throw new Error("initializeWasm() must be awaited first!");
2210 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2211 return nativeResponseValue;
2214 export function LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr: number): number {
2215 if(!isWasmInitialized) {
2216 throw new Error("initializeWasm() must be awaited first!");
2218 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr);
2219 return nativeResponseValue;
2222 export function LDKMessageSendEvent_SendFundingLocked_get_msg(ptr: number): number {
2223 if(!isWasmInitialized) {
2224 throw new Error("initializeWasm() must be awaited first!");
2226 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_msg(ptr);
2227 return nativeResponseValue;
2230 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
2231 if(!isWasmInitialized) {
2232 throw new Error("initializeWasm() must be awaited first!");
2234 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2235 return nativeResponseValue;
2238 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
2239 if(!isWasmInitialized) {
2240 throw new Error("initializeWasm() must be awaited first!");
2242 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2243 return nativeResponseValue;
2246 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
2247 if(!isWasmInitialized) {
2248 throw new Error("initializeWasm() must be awaited first!");
2250 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2251 return nativeResponseValue;
2254 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
2255 if(!isWasmInitialized) {
2256 throw new Error("initializeWasm() must be awaited first!");
2258 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2259 return nativeResponseValue;
2262 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
2263 if(!isWasmInitialized) {
2264 throw new Error("initializeWasm() must be awaited first!");
2266 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2267 return nativeResponseValue;
2270 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
2271 if(!isWasmInitialized) {
2272 throw new Error("initializeWasm() must be awaited first!");
2274 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2275 return nativeResponseValue;
2278 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
2279 if(!isWasmInitialized) {
2280 throw new Error("initializeWasm() must be awaited first!");
2282 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2283 return nativeResponseValue;
2286 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
2287 if(!isWasmInitialized) {
2288 throw new Error("initializeWasm() must be awaited first!");
2290 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2291 return nativeResponseValue;
2294 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
2295 if(!isWasmInitialized) {
2296 throw new Error("initializeWasm() must be awaited first!");
2298 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2299 return nativeResponseValue;
2302 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
2303 if(!isWasmInitialized) {
2304 throw new Error("initializeWasm() must be awaited first!");
2306 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2307 return nativeResponseValue;
2310 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2311 if(!isWasmInitialized) {
2312 throw new Error("initializeWasm() must be awaited first!");
2314 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2315 return nativeResponseValue;
2318 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2319 if(!isWasmInitialized) {
2320 throw new Error("initializeWasm() must be awaited first!");
2322 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2323 return nativeResponseValue;
2326 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2327 if(!isWasmInitialized) {
2328 throw new Error("initializeWasm() must be awaited first!");
2330 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2331 return nativeResponseValue;
2334 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2335 if(!isWasmInitialized) {
2336 throw new Error("initializeWasm() must be awaited first!");
2338 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2339 return nativeResponseValue;
2342 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2343 if(!isWasmInitialized) {
2344 throw new Error("initializeWasm() must be awaited first!");
2346 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2347 return nativeResponseValue;
2350 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2351 if(!isWasmInitialized) {
2352 throw new Error("initializeWasm() must be awaited first!");
2354 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2355 return nativeResponseValue;
2358 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2359 if(!isWasmInitialized) {
2360 throw new Error("initializeWasm() must be awaited first!");
2362 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2363 return nativeResponseValue;
2366 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2367 if(!isWasmInitialized) {
2368 throw new Error("initializeWasm() must be awaited first!");
2370 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2371 return nativeResponseValue;
2374 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2375 if(!isWasmInitialized) {
2376 throw new Error("initializeWasm() must be awaited first!");
2378 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2379 return nativeResponseValue;
2382 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2383 if(!isWasmInitialized) {
2384 throw new Error("initializeWasm() must be awaited first!");
2386 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2387 return nativeResponseValue;
2390 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2391 if(!isWasmInitialized) {
2392 throw new Error("initializeWasm() must be awaited first!");
2394 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2395 return nativeResponseValue;
2398 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2399 if(!isWasmInitialized) {
2400 throw new Error("initializeWasm() must be awaited first!");
2402 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2403 return nativeResponseValue;
2406 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2407 if(!isWasmInitialized) {
2408 throw new Error("initializeWasm() must be awaited first!");
2410 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2411 return nativeResponseValue;
2414 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2415 if(!isWasmInitialized) {
2416 throw new Error("initializeWasm() must be awaited first!");
2418 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2419 return nativeResponseValue;
2422 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2423 if(!isWasmInitialized) {
2424 throw new Error("initializeWasm() must be awaited first!");
2426 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2427 return nativeResponseValue;
2430 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2431 if(!isWasmInitialized) {
2432 throw new Error("initializeWasm() must be awaited first!");
2434 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2435 return nativeResponseValue;
2437 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2439 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2440 if(!isWasmInitialized) {
2441 throw new Error("initializeWasm() must be awaited first!");
2443 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2444 return nativeResponseValue;
2446 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2448 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2449 if(!isWasmInitialized) {
2450 throw new Error("initializeWasm() must be awaited first!");
2452 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2453 return nativeResponseValue;
2455 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2457 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2458 if(!isWasmInitialized) {
2459 throw new Error("initializeWasm() must be awaited first!");
2461 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2462 return nativeResponseValue;
2464 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2466 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2467 if(!isWasmInitialized) {
2468 throw new Error("initializeWasm() must be awaited first!");
2470 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2471 return nativeResponseValue;
2473 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2475 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2476 if(!isWasmInitialized) {
2477 throw new Error("initializeWasm() must be awaited first!");
2479 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2480 return nativeResponseValue;
2482 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
2484 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
2485 if(!isWasmInitialized) {
2486 throw new Error("initializeWasm() must be awaited first!");
2488 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
2489 return nativeResponseValue;
2491 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
2493 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
2494 if(!isWasmInitialized) {
2495 throw new Error("initializeWasm() must be awaited first!");
2497 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
2498 return nativeResponseValue;
2500 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
2502 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
2503 if(!isWasmInitialized) {
2504 throw new Error("initializeWasm() must be awaited first!");
2506 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
2507 // debug statements here
2509 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
2511 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
2512 if(!isWasmInitialized) {
2513 throw new Error("initializeWasm() must be awaited first!");
2515 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
2516 return nativeResponseValue;
2518 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
2520 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
2521 if(!isWasmInitialized) {
2522 throw new Error("initializeWasm() must be awaited first!");
2524 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
2525 return nativeResponseValue;
2527 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
2529 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
2530 if(!isWasmInitialized) {
2531 throw new Error("initializeWasm() must be awaited first!");
2533 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
2534 return nativeResponseValue;
2536 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2538 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2539 if(!isWasmInitialized) {
2540 throw new Error("initializeWasm() must be awaited first!");
2542 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2543 return nativeResponseValue;
2545 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2547 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2548 if(!isWasmInitialized) {
2549 throw new Error("initializeWasm() must be awaited first!");
2551 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2552 return nativeResponseValue;
2554 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2556 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2557 if(!isWasmInitialized) {
2558 throw new Error("initializeWasm() must be awaited first!");
2560 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2561 // debug statements here
2563 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2565 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2566 if(!isWasmInitialized) {
2567 throw new Error("initializeWasm() must be awaited first!");
2569 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2570 return nativeResponseValue;
2573 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2574 protected constructor() {}
2577 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2578 if(!isWasmInitialized) {
2579 throw new Error("initializeWasm() must be awaited first!");
2581 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2582 return nativeResponseValue;
2585 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2586 if(!isWasmInitialized) {
2587 throw new Error("initializeWasm() must be awaited first!");
2589 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2590 return nativeResponseValue;
2593 export class LDKCOption_ClosureReasonZ {
2594 protected constructor() {}
2597 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
2598 if(!isWasmInitialized) {
2599 throw new Error("initializeWasm() must be awaited first!");
2601 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
2602 return nativeResponseValue;
2605 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
2606 if(!isWasmInitialized) {
2607 throw new Error("initializeWasm() must be awaited first!");
2609 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
2610 return nativeResponseValue;
2612 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
2614 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
2615 if(!isWasmInitialized) {
2616 throw new Error("initializeWasm() must be awaited first!");
2618 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
2619 return nativeResponseValue;
2621 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
2623 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
2624 if(!isWasmInitialized) {
2625 throw new Error("initializeWasm() must be awaited first!");
2627 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
2628 return nativeResponseValue;
2631 export class LDKCOption_EventZ {
2632 protected constructor() {}
2635 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
2636 if(!isWasmInitialized) {
2637 throw new Error("initializeWasm() must be awaited first!");
2639 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
2640 return nativeResponseValue;
2643 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
2644 if(!isWasmInitialized) {
2645 throw new Error("initializeWasm() must be awaited first!");
2647 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
2648 return nativeResponseValue;
2650 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2652 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
2653 if(!isWasmInitialized) {
2654 throw new Error("initializeWasm() must be awaited first!");
2656 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
2657 return nativeResponseValue;
2659 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2661 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
2662 if(!isWasmInitialized) {
2663 throw new Error("initializeWasm() must be awaited first!");
2665 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
2666 return nativeResponseValue;
2668 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2670 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2671 if(!isWasmInitialized) {
2672 throw new Error("initializeWasm() must be awaited first!");
2674 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2675 return nativeResponseValue;
2677 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2679 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2680 if(!isWasmInitialized) {
2681 throw new Error("initializeWasm() must be awaited first!");
2683 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2684 return nativeResponseValue;
2686 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2688 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2689 if(!isWasmInitialized) {
2690 throw new Error("initializeWasm() must be awaited first!");
2692 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2693 return nativeResponseValue;
2695 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2697 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2698 if(!isWasmInitialized) {
2699 throw new Error("initializeWasm() must be awaited first!");
2701 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2702 return nativeResponseValue;
2705 export interface LDKAccess {
2706 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2710 export function LDKAccess_new(impl: LDKAccess): number {
2711 if(!isWasmInitialized) {
2712 throw new Error("initializeWasm() must be awaited first!");
2714 var new_obj_idx = js_objs.length;
2715 for (var i = 0; i < js_objs.length; i++) {
2716 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2718 js_objs[i] = new WeakRef(impl);
2719 return wasm.TS_LDKAccess_new(i);
2721 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2723 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2724 if(!isWasmInitialized) {
2725 throw new Error("initializeWasm() must be awaited first!");
2727 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2728 return nativeResponseValue;
2731 export class LDKCOption_AccessZ {
2732 protected constructor() {}
2735 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2736 if(!isWasmInitialized) {
2737 throw new Error("initializeWasm() must be awaited first!");
2739 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2740 return nativeResponseValue;
2743 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2744 if(!isWasmInitialized) {
2745 throw new Error("initializeWasm() must be awaited first!");
2747 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2748 return nativeResponseValue;
2750 // struct LDKDirectionalChannelInfo CResult_DirectionalChannelInfoDecodeErrorZ_get_ok(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2752 export function CResult_DirectionalChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2753 if(!isWasmInitialized) {
2754 throw new Error("initializeWasm() must be awaited first!");
2756 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_get_ok(owner);
2757 return nativeResponseValue;
2759 // struct LDKDecodeError CResult_DirectionalChannelInfoDecodeErrorZ_get_err(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2761 export function CResult_DirectionalChannelInfoDecodeErrorZ_get_err(owner: number): number {
2762 if(!isWasmInitialized) {
2763 throw new Error("initializeWasm() must be awaited first!");
2765 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_get_err(owner);
2766 return nativeResponseValue;
2768 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2770 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2771 if(!isWasmInitialized) {
2772 throw new Error("initializeWasm() must be awaited first!");
2774 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2775 return nativeResponseValue;
2777 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2779 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2780 if(!isWasmInitialized) {
2781 throw new Error("initializeWasm() must be awaited first!");
2783 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2784 return nativeResponseValue;
2786 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2788 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2789 if(!isWasmInitialized) {
2790 throw new Error("initializeWasm() must be awaited first!");
2792 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2793 return nativeResponseValue;
2795 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2797 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2798 if(!isWasmInitialized) {
2799 throw new Error("initializeWasm() must be awaited first!");
2801 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2802 return nativeResponseValue;
2805 export class LDKNetAddress {
2806 protected constructor() {}
2809 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2810 if(!isWasmInitialized) {
2811 throw new Error("initializeWasm() must be awaited first!");
2813 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2814 return nativeResponseValue;
2817 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2818 if(!isWasmInitialized) {
2819 throw new Error("initializeWasm() must be awaited first!");
2821 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2822 return nativeResponseValue;
2825 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2826 if(!isWasmInitialized) {
2827 throw new Error("initializeWasm() must be awaited first!");
2829 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2830 return nativeResponseValue;
2833 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2834 if(!isWasmInitialized) {
2835 throw new Error("initializeWasm() must be awaited first!");
2837 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2838 return nativeResponseValue;
2841 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2842 if(!isWasmInitialized) {
2843 throw new Error("initializeWasm() must be awaited first!");
2845 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2846 return nativeResponseValue;
2849 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2850 if(!isWasmInitialized) {
2851 throw new Error("initializeWasm() must be awaited first!");
2853 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2854 return nativeResponseValue;
2857 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2858 if(!isWasmInitialized) {
2859 throw new Error("initializeWasm() must be awaited first!");
2861 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2862 return nativeResponseValue;
2865 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2866 if(!isWasmInitialized) {
2867 throw new Error("initializeWasm() must be awaited first!");
2869 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2870 return nativeResponseValue;
2873 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2874 if(!isWasmInitialized) {
2875 throw new Error("initializeWasm() must be awaited first!");
2877 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2878 return nativeResponseValue;
2881 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2882 if(!isWasmInitialized) {
2883 throw new Error("initializeWasm() must be awaited first!");
2885 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2886 return nativeResponseValue;
2888 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2890 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2891 if(!isWasmInitialized) {
2892 throw new Error("initializeWasm() must be awaited first!");
2894 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2895 return nativeResponseValue;
2897 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2899 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2900 if(!isWasmInitialized) {
2901 throw new Error("initializeWasm() must be awaited first!");
2903 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2904 return nativeResponseValue;
2906 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2908 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2909 if(!isWasmInitialized) {
2910 throw new Error("initializeWasm() must be awaited first!");
2912 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
2913 return nativeResponseValue;
2915 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2917 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
2918 if(!isWasmInitialized) {
2919 throw new Error("initializeWasm() must be awaited first!");
2921 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
2922 return nativeResponseValue;
2924 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2926 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
2927 if(!isWasmInitialized) {
2928 throw new Error("initializeWasm() must be awaited first!");
2930 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
2931 return nativeResponseValue;
2933 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2935 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
2936 if(!isWasmInitialized) {
2937 throw new Error("initializeWasm() must be awaited first!");
2939 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
2940 return nativeResponseValue;
2943 export class LDKCOption_CVec_NetAddressZZ {
2944 protected constructor() {}
2947 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
2948 if(!isWasmInitialized) {
2949 throw new Error("initializeWasm() must be awaited first!");
2951 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
2952 return nativeResponseValue;
2955 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
2956 if(!isWasmInitialized) {
2957 throw new Error("initializeWasm() must be awaited first!");
2959 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
2960 return nativeResponseValue;
2962 // struct LDKScoringParameters *CResult_ScoringParametersDecodeErrorZ_get_ok(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2964 export function CResult_ScoringParametersDecodeErrorZ_get_ok(owner: number): number {
2965 if(!isWasmInitialized) {
2966 throw new Error("initializeWasm() must be awaited first!");
2968 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_ok(owner);
2969 return nativeResponseValue;
2971 // struct LDKDecodeError CResult_ScoringParametersDecodeErrorZ_get_err(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2973 export function CResult_ScoringParametersDecodeErrorZ_get_err(owner: number): number {
2974 if(!isWasmInitialized) {
2975 throw new Error("initializeWasm() must be awaited first!");
2977 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_err(owner);
2978 return nativeResponseValue;
2980 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2982 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2983 if(!isWasmInitialized) {
2984 throw new Error("initializeWasm() must be awaited first!");
2986 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2987 return nativeResponseValue;
2989 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2991 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2992 if(!isWasmInitialized) {
2993 throw new Error("initializeWasm() must be awaited first!");
2995 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2996 return nativeResponseValue;
2998 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
3000 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
3001 if(!isWasmInitialized) {
3002 throw new Error("initializeWasm() must be awaited first!");
3004 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
3005 return nativeResponseValue;
3007 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
3009 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
3010 if(!isWasmInitialized) {
3011 throw new Error("initializeWasm() must be awaited first!");
3013 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
3014 return nativeResponseValue;
3016 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3018 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
3019 if(!isWasmInitialized) {
3020 throw new Error("initializeWasm() must be awaited first!");
3022 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
3023 return nativeResponseValue;
3025 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3027 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
3028 if(!isWasmInitialized) {
3029 throw new Error("initializeWasm() must be awaited first!");
3031 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
3032 return nativeResponseValue;
3034 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3036 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
3041 return nativeResponseValue;
3043 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3045 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
3050 return nativeResponseValue;
3052 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3054 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
3055 if(!isWasmInitialized) {
3056 throw new Error("initializeWasm() must be awaited first!");
3058 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
3059 return nativeResponseValue;
3061 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3063 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
3068 return nativeResponseValue;
3070 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
3072 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
3077 return nativeResponseValue;
3079 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
3081 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
3086 return nativeResponseValue;
3088 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
3090 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
3095 return nativeResponseValue;
3097 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
3099 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
3104 return nativeResponseValue;
3106 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
3108 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
3113 return nativeResponseValue;
3115 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
3117 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
3122 return nativeResponseValue;
3124 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
3126 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
3131 return nativeResponseValue;
3133 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
3135 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
3140 return nativeResponseValue;
3142 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
3144 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
3149 return nativeResponseValue;
3151 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
3153 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
3158 return nativeResponseValue;
3160 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
3162 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
3167 return nativeResponseValue;
3169 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
3171 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
3172 if(!isWasmInitialized) {
3173 throw new Error("initializeWasm() must be awaited first!");
3175 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
3176 return nativeResponseValue;
3178 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
3180 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
3185 return nativeResponseValue;
3187 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
3189 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
3194 return nativeResponseValue;
3196 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
3198 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
3203 return nativeResponseValue;
3205 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
3207 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
3212 return nativeResponseValue;
3214 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
3216 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
3221 return nativeResponseValue;
3223 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
3225 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
3230 return nativeResponseValue;
3232 // struct LDKFundingLocked CResult_FundingLockedDecodeErrorZ_get_ok(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
3234 export function CResult_FundingLockedDecodeErrorZ_get_ok(owner: number): number {
3235 if(!isWasmInitialized) {
3236 throw new Error("initializeWasm() must be awaited first!");
3238 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_ok(owner);
3239 return nativeResponseValue;
3241 // struct LDKDecodeError CResult_FundingLockedDecodeErrorZ_get_err(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
3243 export function CResult_FundingLockedDecodeErrorZ_get_err(owner: number): number {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_err(owner);
3248 return nativeResponseValue;
3250 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
3252 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
3257 return nativeResponseValue;
3259 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
3261 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
3262 if(!isWasmInitialized) {
3263 throw new Error("initializeWasm() must be awaited first!");
3265 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
3266 return nativeResponseValue;
3268 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
3270 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
3271 if(!isWasmInitialized) {
3272 throw new Error("initializeWasm() must be awaited first!");
3274 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
3275 return nativeResponseValue;
3277 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
3279 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
3280 if(!isWasmInitialized) {
3281 throw new Error("initializeWasm() must be awaited first!");
3283 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
3284 return nativeResponseValue;
3286 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
3288 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
3289 if(!isWasmInitialized) {
3290 throw new Error("initializeWasm() must be awaited first!");
3292 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
3293 return nativeResponseValue;
3295 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
3297 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
3298 if(!isWasmInitialized) {
3299 throw new Error("initializeWasm() must be awaited first!");
3301 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
3302 return nativeResponseValue;
3304 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
3306 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
3307 if(!isWasmInitialized) {
3308 throw new Error("initializeWasm() must be awaited first!");
3310 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
3311 return nativeResponseValue;
3313 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
3315 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
3316 if(!isWasmInitialized) {
3317 throw new Error("initializeWasm() must be awaited first!");
3319 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
3320 return nativeResponseValue;
3322 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
3324 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
3325 if(!isWasmInitialized) {
3326 throw new Error("initializeWasm() must be awaited first!");
3328 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
3329 return nativeResponseValue;
3331 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
3333 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
3334 if(!isWasmInitialized) {
3335 throw new Error("initializeWasm() must be awaited first!");
3337 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
3338 return nativeResponseValue;
3340 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
3342 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
3343 if(!isWasmInitialized) {
3344 throw new Error("initializeWasm() must be awaited first!");
3346 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
3347 return nativeResponseValue;
3349 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
3351 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
3352 if(!isWasmInitialized) {
3353 throw new Error("initializeWasm() must be awaited first!");
3355 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
3356 return nativeResponseValue;
3358 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
3360 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
3361 if(!isWasmInitialized) {
3362 throw new Error("initializeWasm() must be awaited first!");
3364 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
3365 return nativeResponseValue;
3367 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
3369 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
3370 if(!isWasmInitialized) {
3371 throw new Error("initializeWasm() must be awaited first!");
3373 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
3374 return nativeResponseValue;
3376 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
3378 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
3379 if(!isWasmInitialized) {
3380 throw new Error("initializeWasm() must be awaited first!");
3382 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
3383 return nativeResponseValue;
3385 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
3387 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
3388 if(!isWasmInitialized) {
3389 throw new Error("initializeWasm() must be awaited first!");
3391 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
3392 return nativeResponseValue;
3394 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
3396 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
3401 return nativeResponseValue;
3403 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
3405 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
3406 if(!isWasmInitialized) {
3407 throw new Error("initializeWasm() must be awaited first!");
3409 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
3410 return nativeResponseValue;
3412 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
3414 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
3415 if(!isWasmInitialized) {
3416 throw new Error("initializeWasm() must be awaited first!");
3418 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
3419 return nativeResponseValue;
3421 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
3423 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
3424 if(!isWasmInitialized) {
3425 throw new Error("initializeWasm() must be awaited first!");
3427 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
3428 return nativeResponseValue;
3430 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
3432 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
3433 if(!isWasmInitialized) {
3434 throw new Error("initializeWasm() must be awaited first!");
3436 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
3437 return nativeResponseValue;
3439 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
3441 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
3442 if(!isWasmInitialized) {
3443 throw new Error("initializeWasm() must be awaited first!");
3445 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
3446 return nativeResponseValue;
3448 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3450 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3451 if(!isWasmInitialized) {
3452 throw new Error("initializeWasm() must be awaited first!");
3454 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
3455 return nativeResponseValue;
3457 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3459 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
3460 if(!isWasmInitialized) {
3461 throw new Error("initializeWasm() must be awaited first!");
3463 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
3464 return nativeResponseValue;
3466 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3468 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3469 if(!isWasmInitialized) {
3470 throw new Error("initializeWasm() must be awaited first!");
3472 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
3473 return nativeResponseValue;
3475 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3477 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
3478 if(!isWasmInitialized) {
3479 throw new Error("initializeWasm() must be awaited first!");
3481 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
3482 return nativeResponseValue;
3484 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3486 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
3487 if(!isWasmInitialized) {
3488 throw new Error("initializeWasm() must be awaited first!");
3490 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
3491 return nativeResponseValue;
3493 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3495 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
3496 if(!isWasmInitialized) {
3497 throw new Error("initializeWasm() must be awaited first!");
3499 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
3500 return nativeResponseValue;
3502 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3504 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
3505 if(!isWasmInitialized) {
3506 throw new Error("initializeWasm() must be awaited first!");
3508 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
3509 return nativeResponseValue;
3511 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3513 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
3514 if(!isWasmInitialized) {
3515 throw new Error("initializeWasm() must be awaited first!");
3517 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
3518 return nativeResponseValue;
3520 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
3522 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
3523 if(!isWasmInitialized) {
3524 throw new Error("initializeWasm() must be awaited first!");
3526 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
3527 return nativeResponseValue;
3529 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
3531 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
3532 if(!isWasmInitialized) {
3533 throw new Error("initializeWasm() must be awaited first!");
3535 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
3536 return nativeResponseValue;
3538 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3540 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3541 if(!isWasmInitialized) {
3542 throw new Error("initializeWasm() must be awaited first!");
3544 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
3545 return nativeResponseValue;
3547 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3549 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
3550 if(!isWasmInitialized) {
3551 throw new Error("initializeWasm() must be awaited first!");
3553 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
3554 return nativeResponseValue;
3556 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3558 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3559 if(!isWasmInitialized) {
3560 throw new Error("initializeWasm() must be awaited first!");
3562 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
3563 return nativeResponseValue;
3565 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3567 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
3568 if(!isWasmInitialized) {
3569 throw new Error("initializeWasm() must be awaited first!");
3571 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
3572 return nativeResponseValue;
3574 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
3576 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
3577 if(!isWasmInitialized) {
3578 throw new Error("initializeWasm() must be awaited first!");
3580 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
3581 return nativeResponseValue;
3583 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
3585 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
3586 if(!isWasmInitialized) {
3587 throw new Error("initializeWasm() must be awaited first!");
3589 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
3590 return nativeResponseValue;
3592 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
3594 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
3595 if(!isWasmInitialized) {
3596 throw new Error("initializeWasm() must be awaited first!");
3598 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
3599 return nativeResponseValue;
3601 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
3603 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
3604 if(!isWasmInitialized) {
3605 throw new Error("initializeWasm() must be awaited first!");
3607 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
3608 return nativeResponseValue;
3610 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3612 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
3613 if(!isWasmInitialized) {
3614 throw new Error("initializeWasm() must be awaited first!");
3616 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
3617 return nativeResponseValue;
3619 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3621 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
3622 if(!isWasmInitialized) {
3623 throw new Error("initializeWasm() must be awaited first!");
3625 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
3626 return nativeResponseValue;
3628 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3630 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
3631 if(!isWasmInitialized) {
3632 throw new Error("initializeWasm() must be awaited first!");
3634 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
3635 return nativeResponseValue;
3637 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3639 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
3640 if(!isWasmInitialized) {
3641 throw new Error("initializeWasm() must be awaited first!");
3643 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
3644 return nativeResponseValue;
3646 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
3648 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
3649 if(!isWasmInitialized) {
3650 throw new Error("initializeWasm() must be awaited first!");
3652 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
3653 return nativeResponseValue;
3655 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
3657 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
3658 if(!isWasmInitialized) {
3659 throw new Error("initializeWasm() must be awaited first!");
3661 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
3662 return nativeResponseValue;
3664 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3666 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3667 if(!isWasmInitialized) {
3668 throw new Error("initializeWasm() must be awaited first!");
3670 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3671 return nativeResponseValue;
3673 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3675 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3676 if(!isWasmInitialized) {
3677 throw new Error("initializeWasm() must be awaited first!");
3679 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3680 return nativeResponseValue;
3682 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3684 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3685 if(!isWasmInitialized) {
3686 throw new Error("initializeWasm() must be awaited first!");
3688 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3689 return nativeResponseValue;
3691 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3693 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3694 if(!isWasmInitialized) {
3695 throw new Error("initializeWasm() must be awaited first!");
3697 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3698 return nativeResponseValue;
3700 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3702 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3703 if(!isWasmInitialized) {
3704 throw new Error("initializeWasm() must be awaited first!");
3706 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3707 return nativeResponseValue;
3709 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3711 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3716 return nativeResponseValue;
3718 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3720 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3721 if(!isWasmInitialized) {
3722 throw new Error("initializeWasm() must be awaited first!");
3724 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3725 return nativeResponseValue;
3727 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3729 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3730 if(!isWasmInitialized) {
3731 throw new Error("initializeWasm() must be awaited first!");
3733 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3734 return nativeResponseValue;
3736 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3738 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3739 if(!isWasmInitialized) {
3740 throw new Error("initializeWasm() must be awaited first!");
3742 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3743 return nativeResponseValue;
3745 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3747 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3748 if(!isWasmInitialized) {
3749 throw new Error("initializeWasm() must be awaited first!");
3751 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3752 // debug statements here
3754 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3756 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3757 if(!isWasmInitialized) {
3758 throw new Error("initializeWasm() must be awaited first!");
3760 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3761 return nativeResponseValue;
3763 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3765 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3766 if(!isWasmInitialized) {
3767 throw new Error("initializeWasm() must be awaited first!");
3769 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3770 // debug statements here
3772 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3774 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3775 if(!isWasmInitialized) {
3776 throw new Error("initializeWasm() must be awaited first!");
3778 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3779 return nativeResponseValue;
3781 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3783 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3784 if(!isWasmInitialized) {
3785 throw new Error("initializeWasm() must be awaited first!");
3787 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3788 return nativeResponseValue;
3790 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3792 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3793 if(!isWasmInitialized) {
3794 throw new Error("initializeWasm() must be awaited first!");
3796 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3797 return nativeResponseValue;
3799 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3801 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3802 if(!isWasmInitialized) {
3803 throw new Error("initializeWasm() must be awaited first!");
3805 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3806 // debug statements here
3809 export interface LDKFilter {
3810 register_tx (txid: number, script_pubkey: number): void;
3811 register_output (output: number): number;
3815 export function LDKFilter_new(impl: LDKFilter): number {
3816 if(!isWasmInitialized) {
3817 throw new Error("initializeWasm() must be awaited first!");
3819 var new_obj_idx = js_objs.length;
3820 for (var i = 0; i < js_objs.length; i++) {
3821 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3823 js_objs[i] = new WeakRef(impl);
3824 return wasm.TS_LDKFilter_new(i);
3826 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
3828 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
3829 if(!isWasmInitialized) {
3830 throw new Error("initializeWasm() must be awaited first!");
3832 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
3833 // debug statements here
3835 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
3837 export function Filter_register_output(this_arg: number, output: number): number {
3838 if(!isWasmInitialized) {
3839 throw new Error("initializeWasm() must be awaited first!");
3841 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
3842 return nativeResponseValue;
3845 export class LDKCOption_FilterZ {
3846 protected constructor() {}
3849 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
3850 if(!isWasmInitialized) {
3851 throw new Error("initializeWasm() must be awaited first!");
3853 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
3854 return nativeResponseValue;
3857 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
3858 if(!isWasmInitialized) {
3859 throw new Error("initializeWasm() must be awaited first!");
3861 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
3862 return nativeResponseValue;
3864 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
3866 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
3867 if(!isWasmInitialized) {
3868 throw new Error("initializeWasm() must be awaited first!");
3870 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
3871 return nativeResponseValue;
3873 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
3875 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
3876 if(!isWasmInitialized) {
3877 throw new Error("initializeWasm() must be awaited first!");
3879 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
3880 // debug statements here
3883 export class LDKAPIError {
3884 protected constructor() {}
3887 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3888 if(!isWasmInitialized) {
3889 throw new Error("initializeWasm() must be awaited first!");
3891 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3892 return nativeResponseValue;
3895 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3896 if(!isWasmInitialized) {
3897 throw new Error("initializeWasm() must be awaited first!");
3899 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3900 return nativeResponseValue;
3903 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3904 if(!isWasmInitialized) {
3905 throw new Error("initializeWasm() must be awaited first!");
3907 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3908 return nativeResponseValue;
3911 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3912 if(!isWasmInitialized) {
3913 throw new Error("initializeWasm() must be awaited first!");
3915 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3916 return nativeResponseValue;
3919 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3920 if(!isWasmInitialized) {
3921 throw new Error("initializeWasm() must be awaited first!");
3923 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3924 return nativeResponseValue;
3927 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3928 if(!isWasmInitialized) {
3929 throw new Error("initializeWasm() must be awaited first!");
3931 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3932 return nativeResponseValue;
3935 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3936 if(!isWasmInitialized) {
3937 throw new Error("initializeWasm() must be awaited first!");
3939 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3940 return nativeResponseValue;
3942 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3944 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3945 if(!isWasmInitialized) {
3946 throw new Error("initializeWasm() must be awaited first!");
3948 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3949 // debug statements here
3951 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3953 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3954 if(!isWasmInitialized) {
3955 throw new Error("initializeWasm() must be awaited first!");
3957 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3958 return nativeResponseValue;
3961 export class LDKCOption_u16Z {
3962 protected constructor() {}
3965 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3966 if(!isWasmInitialized) {
3967 throw new Error("initializeWasm() must be awaited first!");
3969 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3970 return nativeResponseValue;
3973 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3974 if(!isWasmInitialized) {
3975 throw new Error("initializeWasm() must be awaited first!");
3977 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3978 return nativeResponseValue;
3980 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3982 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3983 if(!isWasmInitialized) {
3984 throw new Error("initializeWasm() must be awaited first!");
3986 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3987 return nativeResponseValue;
3989 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3991 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3992 if(!isWasmInitialized) {
3993 throw new Error("initializeWasm() must be awaited first!");
3995 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3996 return nativeResponseValue;
3999 export class LDKPaymentSendFailure {
4000 protected constructor() {}
4003 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
4004 if(!isWasmInitialized) {
4005 throw new Error("initializeWasm() must be awaited first!");
4007 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
4008 return nativeResponseValue;
4011 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
4012 if(!isWasmInitialized) {
4013 throw new Error("initializeWasm() must be awaited first!");
4015 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
4016 return nativeResponseValue;
4019 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
4020 if(!isWasmInitialized) {
4021 throw new Error("initializeWasm() must be awaited first!");
4023 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4024 return nativeResponseValue;
4027 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
4028 if(!isWasmInitialized) {
4029 throw new Error("initializeWasm() must be awaited first!");
4031 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
4032 return nativeResponseValue;
4035 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
4036 if(!isWasmInitialized) {
4037 throw new Error("initializeWasm() must be awaited first!");
4039 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4040 return nativeResponseValue;
4043 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
4044 if(!isWasmInitialized) {
4045 throw new Error("initializeWasm() must be awaited first!");
4047 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4048 return nativeResponseValue;
4051 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
4052 if(!isWasmInitialized) {
4053 throw new Error("initializeWasm() must be awaited first!");
4055 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4056 return nativeResponseValue;
4058 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
4060 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
4061 if(!isWasmInitialized) {
4062 throw new Error("initializeWasm() must be awaited first!");
4064 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
4065 return nativeResponseValue;
4067 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
4069 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
4070 if(!isWasmInitialized) {
4071 throw new Error("initializeWasm() must be awaited first!");
4073 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
4074 return nativeResponseValue;
4076 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4078 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
4079 if(!isWasmInitialized) {
4080 throw new Error("initializeWasm() must be awaited first!");
4082 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4083 // debug statements here
4085 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4087 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4092 return nativeResponseValue;
4094 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4096 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
4097 if(!isWasmInitialized) {
4098 throw new Error("initializeWasm() must be awaited first!");
4100 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
4101 return nativeResponseValue;
4103 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4105 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
4106 if(!isWasmInitialized) {
4107 throw new Error("initializeWasm() must be awaited first!");
4109 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
4110 return nativeResponseValue;
4112 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4114 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
4115 if(!isWasmInitialized) {
4116 throw new Error("initializeWasm() must be awaited first!");
4118 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
4119 return nativeResponseValue;
4121 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4123 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
4124 if(!isWasmInitialized) {
4125 throw new Error("initializeWasm() must be awaited first!");
4127 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
4128 return nativeResponseValue;
4130 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4132 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
4133 if(!isWasmInitialized) {
4134 throw new Error("initializeWasm() must be awaited first!");
4136 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
4137 return nativeResponseValue;
4139 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4141 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
4142 if(!isWasmInitialized) {
4143 throw new Error("initializeWasm() must be awaited first!");
4145 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
4146 return nativeResponseValue;
4148 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4150 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
4151 if(!isWasmInitialized) {
4152 throw new Error("initializeWasm() must be awaited first!");
4154 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
4155 return nativeResponseValue;
4157 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4159 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
4160 if(!isWasmInitialized) {
4161 throw new Error("initializeWasm() must be awaited first!");
4163 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
4164 // debug statements here
4166 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4168 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
4169 if(!isWasmInitialized) {
4170 throw new Error("initializeWasm() must be awaited first!");
4172 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
4173 return nativeResponseValue;
4175 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4177 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
4178 if(!isWasmInitialized) {
4179 throw new Error("initializeWasm() must be awaited first!");
4181 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
4182 return nativeResponseValue;
4184 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4186 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
4187 if(!isWasmInitialized) {
4188 throw new Error("initializeWasm() must be awaited first!");
4190 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
4191 return nativeResponseValue;
4193 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4195 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
4196 if(!isWasmInitialized) {
4197 throw new Error("initializeWasm() must be awaited first!");
4199 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
4200 // debug statements here
4202 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4204 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
4205 if(!isWasmInitialized) {
4206 throw new Error("initializeWasm() must be awaited first!");
4208 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
4209 return nativeResponseValue;
4211 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4213 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
4214 if(!isWasmInitialized) {
4215 throw new Error("initializeWasm() must be awaited first!");
4217 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
4218 return nativeResponseValue;
4220 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4222 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
4223 if(!isWasmInitialized) {
4224 throw new Error("initializeWasm() must be awaited first!");
4226 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
4227 return nativeResponseValue;
4229 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4231 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
4232 if(!isWasmInitialized) {
4233 throw new Error("initializeWasm() must be awaited first!");
4235 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
4236 return nativeResponseValue;
4239 export interface LDKWatch {
4240 watch_channel (funding_txo: number, monitor: number): number;
4241 update_channel (funding_txo: number, update: number): number;
4242 release_pending_monitor_events (): number;
4246 export function LDKWatch_new(impl: LDKWatch): number {
4247 if(!isWasmInitialized) {
4248 throw new Error("initializeWasm() must be awaited first!");
4250 var new_obj_idx = js_objs.length;
4251 for (var i = 0; i < js_objs.length; i++) {
4252 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4254 js_objs[i] = new WeakRef(impl);
4255 return wasm.TS_LDKWatch_new(i);
4257 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4259 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
4260 if(!isWasmInitialized) {
4261 throw new Error("initializeWasm() must be awaited first!");
4263 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4264 return nativeResponseValue;
4266 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
4268 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
4269 if(!isWasmInitialized) {
4270 throw new Error("initializeWasm() must be awaited first!");
4272 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4273 return nativeResponseValue;
4275 // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4277 export function Watch_release_pending_monitor_events(this_arg: number): number {
4278 if(!isWasmInitialized) {
4279 throw new Error("initializeWasm() must be awaited first!");
4281 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4282 return nativeResponseValue;
4285 export interface LDKBroadcasterInterface {
4286 broadcast_transaction (tx: number): void;
4290 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
4291 if(!isWasmInitialized) {
4292 throw new Error("initializeWasm() must be awaited first!");
4294 var new_obj_idx = js_objs.length;
4295 for (var i = 0; i < js_objs.length; i++) {
4296 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4298 js_objs[i] = new WeakRef(impl);
4299 return wasm.TS_LDKBroadcasterInterface_new(i);
4301 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4303 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
4304 if(!isWasmInitialized) {
4305 throw new Error("initializeWasm() must be awaited first!");
4307 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4308 // debug statements here
4311 export interface LDKKeysInterface {
4312 get_node_secret (): number;
4313 get_destination_script (): number;
4314 get_shutdown_scriptpubkey (): number;
4315 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
4316 get_secure_random_bytes (): number;
4317 read_chan_signer (reader: number): number;
4318 sign_invoice (invoice_preimage: number): number;
4319 get_inbound_payment_key_material (): number;
4323 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
4324 if(!isWasmInitialized) {
4325 throw new Error("initializeWasm() must be awaited first!");
4327 var new_obj_idx = js_objs.length;
4328 for (var i = 0; i < js_objs.length; i++) {
4329 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4331 js_objs[i] = new WeakRef(impl);
4332 return wasm.TS_LDKKeysInterface_new(i);
4334 // LDKSecretKey KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg
4336 export function KeysInterface_get_node_secret(this_arg: number): number {
4337 if(!isWasmInitialized) {
4338 throw new Error("initializeWasm() must be awaited first!");
4340 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg);
4341 return nativeResponseValue;
4343 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4345 export function KeysInterface_get_destination_script(this_arg: number): number {
4346 if(!isWasmInitialized) {
4347 throw new Error("initializeWasm() must be awaited first!");
4349 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4350 return nativeResponseValue;
4352 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4354 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
4355 if(!isWasmInitialized) {
4356 throw new Error("initializeWasm() must be awaited first!");
4358 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4359 return nativeResponseValue;
4361 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4363 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
4364 if(!isWasmInitialized) {
4365 throw new Error("initializeWasm() must be awaited first!");
4367 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4368 return nativeResponseValue;
4370 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4372 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
4373 if(!isWasmInitialized) {
4374 throw new Error("initializeWasm() must be awaited first!");
4376 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4377 return nativeResponseValue;
4379 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4381 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4386 return nativeResponseValue;
4388 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKCVec_u8Z invoice_preimage
4390 export function KeysInterface_sign_invoice(this_arg: number, invoice_preimage: number): number {
4391 if(!isWasmInitialized) {
4392 throw new Error("initializeWasm() must be awaited first!");
4394 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, invoice_preimage);
4395 return nativeResponseValue;
4397 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4399 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
4400 if(!isWasmInitialized) {
4401 throw new Error("initializeWasm() must be awaited first!");
4403 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4404 return nativeResponseValue;
4407 export interface LDKFeeEstimator {
4408 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4412 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
4413 if(!isWasmInitialized) {
4414 throw new Error("initializeWasm() must be awaited first!");
4416 var new_obj_idx = js_objs.length;
4417 for (var i = 0; i < js_objs.length; i++) {
4418 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4420 js_objs[i] = new WeakRef(impl);
4421 return wasm.TS_LDKFeeEstimator_new(i);
4423 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4425 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
4426 if(!isWasmInitialized) {
4427 throw new Error("initializeWasm() must be awaited first!");
4429 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4430 return nativeResponseValue;
4433 export interface LDKLogger {
4434 log (record: number): void;
4438 export function LDKLogger_new(impl: LDKLogger): number {
4439 if(!isWasmInitialized) {
4440 throw new Error("initializeWasm() must be awaited first!");
4442 var new_obj_idx = js_objs.length;
4443 for (var i = 0; i < js_objs.length; i++) {
4444 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4446 js_objs[i] = new WeakRef(impl);
4447 return wasm.TS_LDKLogger_new(i);
4449 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4451 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
4452 if(!isWasmInitialized) {
4453 throw new Error("initializeWasm() must be awaited first!");
4455 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4456 return nativeResponseValue;
4458 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4460 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
4461 if(!isWasmInitialized) {
4462 throw new Error("initializeWasm() must be awaited first!");
4464 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4465 return nativeResponseValue;
4467 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4469 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
4470 if(!isWasmInitialized) {
4471 throw new Error("initializeWasm() must be awaited first!");
4473 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4474 return nativeResponseValue;
4476 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4478 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
4479 if(!isWasmInitialized) {
4480 throw new Error("initializeWasm() must be awaited first!");
4482 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4483 return nativeResponseValue;
4486 export interface LDKMessageSendEventsProvider {
4487 get_and_clear_pending_msg_events (): number;
4491 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
4492 if(!isWasmInitialized) {
4493 throw new Error("initializeWasm() must be awaited first!");
4495 var new_obj_idx = js_objs.length;
4496 for (var i = 0; i < js_objs.length; i++) {
4497 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4499 js_objs[i] = new WeakRef(impl);
4500 return wasm.TS_LDKMessageSendEventsProvider_new(i);
4502 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
4504 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
4505 if(!isWasmInitialized) {
4506 throw new Error("initializeWasm() must be awaited first!");
4508 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
4509 return nativeResponseValue;
4512 export interface LDKEventHandler {
4513 handle_event (event: number): void;
4517 export function LDKEventHandler_new(impl: LDKEventHandler): number {
4518 if(!isWasmInitialized) {
4519 throw new Error("initializeWasm() must be awaited first!");
4521 var new_obj_idx = js_objs.length;
4522 for (var i = 0; i < js_objs.length; i++) {
4523 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4525 js_objs[i] = new WeakRef(impl);
4526 return wasm.TS_LDKEventHandler_new(i);
4528 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
4530 export function EventHandler_handle_event(this_arg: number, event: number): void {
4531 if(!isWasmInitialized) {
4532 throw new Error("initializeWasm() must be awaited first!");
4534 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
4535 // debug statements here
4538 export interface LDKEventsProvider {
4539 process_pending_events (handler: number): void;
4543 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
4544 if(!isWasmInitialized) {
4545 throw new Error("initializeWasm() must be awaited first!");
4547 var new_obj_idx = js_objs.length;
4548 for (var i = 0; i < js_objs.length; i++) {
4549 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4551 js_objs[i] = new WeakRef(impl);
4552 return wasm.TS_LDKEventsProvider_new(i);
4554 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
4556 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
4557 if(!isWasmInitialized) {
4558 throw new Error("initializeWasm() must be awaited first!");
4560 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
4561 // debug statements here
4564 export interface LDKListen {
4565 block_connected (block: number, height: number): void;
4566 block_disconnected (header: number, height: number): void;
4570 export function LDKListen_new(impl: LDKListen): number {
4571 if(!isWasmInitialized) {
4572 throw new Error("initializeWasm() must be awaited first!");
4574 var new_obj_idx = js_objs.length;
4575 for (var i = 0; i < js_objs.length; i++) {
4576 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4578 js_objs[i] = new WeakRef(impl);
4579 return wasm.TS_LDKListen_new(i);
4581 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
4583 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
4584 if(!isWasmInitialized) {
4585 throw new Error("initializeWasm() must be awaited first!");
4587 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
4588 // debug statements here
4590 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
4592 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
4593 if(!isWasmInitialized) {
4594 throw new Error("initializeWasm() must be awaited first!");
4596 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
4597 // debug statements here
4600 export interface LDKConfirm {
4601 transactions_confirmed (header: number, txdata: number, height: number): void;
4602 transaction_unconfirmed (txid: number): void;
4603 best_block_updated (header: number, height: number): void;
4604 get_relevant_txids (): number;
4608 export function LDKConfirm_new(impl: LDKConfirm): number {
4609 if(!isWasmInitialized) {
4610 throw new Error("initializeWasm() must be awaited first!");
4612 var new_obj_idx = js_objs.length;
4613 for (var i = 0; i < js_objs.length; i++) {
4614 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4616 js_objs[i] = new WeakRef(impl);
4617 return wasm.TS_LDKConfirm_new(i);
4619 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
4621 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
4622 if(!isWasmInitialized) {
4623 throw new Error("initializeWasm() must be awaited first!");
4625 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
4626 // debug statements here
4628 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
4630 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
4631 if(!isWasmInitialized) {
4632 throw new Error("initializeWasm() must be awaited first!");
4634 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
4635 // debug statements here
4637 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
4639 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
4640 if(!isWasmInitialized) {
4641 throw new Error("initializeWasm() must be awaited first!");
4643 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
4644 // debug statements here
4646 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
4648 export function Confirm_get_relevant_txids(this_arg: number): number {
4649 if(!isWasmInitialized) {
4650 throw new Error("initializeWasm() must be awaited first!");
4652 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
4653 return nativeResponseValue;
4656 export interface LDKPersist {
4657 persist_new_channel (channel_id: number, data: number, update_id: number): number;
4658 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
4662 export function LDKPersist_new(impl: LDKPersist): number {
4663 if(!isWasmInitialized) {
4664 throw new Error("initializeWasm() must be awaited first!");
4666 var new_obj_idx = js_objs.length;
4667 for (var i = 0; i < js_objs.length; i++) {
4668 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4670 js_objs[i] = new WeakRef(impl);
4671 return wasm.TS_LDKPersist_new(i);
4673 // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
4675 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
4676 if(!isWasmInitialized) {
4677 throw new Error("initializeWasm() must be awaited first!");
4679 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
4680 return nativeResponseValue;
4682 // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
4684 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
4685 if(!isWasmInitialized) {
4686 throw new Error("initializeWasm() must be awaited first!");
4688 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
4689 return nativeResponseValue;
4692 export interface LDKChannelMessageHandler {
4693 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
4694 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
4695 handle_funding_created (their_node_id: number, msg: number): void;
4696 handle_funding_signed (their_node_id: number, msg: number): void;
4697 handle_funding_locked (their_node_id: number, msg: number): void;
4698 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
4699 handle_closing_signed (their_node_id: number, msg: number): void;
4700 handle_update_add_htlc (their_node_id: number, msg: number): void;
4701 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
4702 handle_update_fail_htlc (their_node_id: number, msg: number): void;
4703 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
4704 handle_commitment_signed (their_node_id: number, msg: number): void;
4705 handle_revoke_and_ack (their_node_id: number, msg: number): void;
4706 handle_update_fee (their_node_id: number, msg: number): void;
4707 handle_announcement_signatures (their_node_id: number, msg: number): void;
4708 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
4709 peer_connected (their_node_id: number, msg: number): void;
4710 handle_channel_reestablish (their_node_id: number, msg: number): void;
4711 handle_channel_update (their_node_id: number, msg: number): void;
4712 handle_error (their_node_id: number, msg: number): void;
4716 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
4717 if(!isWasmInitialized) {
4718 throw new Error("initializeWasm() must be awaited first!");
4720 var new_obj_idx = js_objs.length;
4721 for (var i = 0; i < js_objs.length; i++) {
4722 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4724 js_objs[i] = new WeakRef(impl);
4725 return wasm.TS_LDKChannelMessageHandler_new(i);
4727 // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg
4729 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
4730 if(!isWasmInitialized) {
4731 throw new Error("initializeWasm() must be awaited first!");
4733 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
4734 // debug statements here
4736 // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg
4738 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
4739 if(!isWasmInitialized) {
4740 throw new Error("initializeWasm() must be awaited first!");
4742 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
4743 // debug statements here
4745 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
4747 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
4748 if(!isWasmInitialized) {
4749 throw new Error("initializeWasm() must be awaited first!");
4751 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
4752 // debug statements here
4754 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
4756 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
4757 if(!isWasmInitialized) {
4758 throw new Error("initializeWasm() must be awaited first!");
4760 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
4761 // debug statements here
4763 // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
4765 export function ChannelMessageHandler_handle_funding_locked(this_arg: number, their_node_id: number, msg: number): void {
4766 if(!isWasmInitialized) {
4767 throw new Error("initializeWasm() must be awaited first!");
4769 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_locked(this_arg, their_node_id, msg);
4770 // debug statements here
4772 // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg
4774 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
4775 if(!isWasmInitialized) {
4776 throw new Error("initializeWasm() must be awaited first!");
4778 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
4779 // debug statements here
4781 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
4783 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
4784 if(!isWasmInitialized) {
4785 throw new Error("initializeWasm() must be awaited first!");
4787 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
4788 // debug statements here
4790 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
4792 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
4793 if(!isWasmInitialized) {
4794 throw new Error("initializeWasm() must be awaited first!");
4796 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
4797 // debug statements here
4799 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
4801 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
4802 if(!isWasmInitialized) {
4803 throw new Error("initializeWasm() must be awaited first!");
4805 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
4806 // debug statements here
4808 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
4810 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
4811 if(!isWasmInitialized) {
4812 throw new Error("initializeWasm() must be awaited first!");
4814 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
4815 // debug statements here
4817 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
4819 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
4820 if(!isWasmInitialized) {
4821 throw new Error("initializeWasm() must be awaited first!");
4823 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
4824 // debug statements here
4826 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
4828 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
4829 if(!isWasmInitialized) {
4830 throw new Error("initializeWasm() must be awaited first!");
4832 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
4833 // debug statements here
4835 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
4837 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
4838 if(!isWasmInitialized) {
4839 throw new Error("initializeWasm() must be awaited first!");
4841 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
4842 // debug statements here
4844 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
4846 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
4847 if(!isWasmInitialized) {
4848 throw new Error("initializeWasm() must be awaited first!");
4850 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
4851 // debug statements here
4853 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
4855 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
4856 if(!isWasmInitialized) {
4857 throw new Error("initializeWasm() must be awaited first!");
4859 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
4860 // debug statements here
4862 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
4864 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
4865 if(!isWasmInitialized) {
4866 throw new Error("initializeWasm() must be awaited first!");
4868 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
4869 // debug statements here
4871 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
4873 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
4874 if(!isWasmInitialized) {
4875 throw new Error("initializeWasm() must be awaited first!");
4877 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
4878 // debug statements here
4880 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
4882 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
4883 if(!isWasmInitialized) {
4884 throw new Error("initializeWasm() must be awaited first!");
4886 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
4887 // debug statements here
4889 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
4891 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
4892 if(!isWasmInitialized) {
4893 throw new Error("initializeWasm() must be awaited first!");
4895 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
4896 // debug statements here
4898 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
4900 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
4901 if(!isWasmInitialized) {
4902 throw new Error("initializeWasm() must be awaited first!");
4904 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
4905 // debug statements here
4908 export interface LDKRoutingMessageHandler {
4909 handle_node_announcement (msg: number): number;
4910 handle_channel_announcement (msg: number): number;
4911 handle_channel_update (msg: number): number;
4912 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
4913 get_next_node_announcements (starting_point: number, batch_amount: number): number;
4914 sync_routing_table (their_node_id: number, init: number): void;
4915 handle_reply_channel_range (their_node_id: number, msg: number): number;
4916 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
4917 handle_query_channel_range (their_node_id: number, msg: number): number;
4918 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
4922 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
4923 if(!isWasmInitialized) {
4924 throw new Error("initializeWasm() must be awaited first!");
4926 var new_obj_idx = js_objs.length;
4927 for (var i = 0; i < js_objs.length; i++) {
4928 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4930 js_objs[i] = new WeakRef(impl);
4931 return wasm.TS_LDKRoutingMessageHandler_new(i);
4933 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
4935 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
4936 if(!isWasmInitialized) {
4937 throw new Error("initializeWasm() must be awaited first!");
4939 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
4940 return nativeResponseValue;
4942 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
4944 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
4945 if(!isWasmInitialized) {
4946 throw new Error("initializeWasm() must be awaited first!");
4948 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
4949 return nativeResponseValue;
4951 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
4953 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
4954 if(!isWasmInitialized) {
4955 throw new Error("initializeWasm() must be awaited first!");
4957 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
4958 return nativeResponseValue;
4960 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
4962 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
4963 if(!isWasmInitialized) {
4964 throw new Error("initializeWasm() must be awaited first!");
4966 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
4967 return nativeResponseValue;
4969 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
4971 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
4972 if(!isWasmInitialized) {
4973 throw new Error("initializeWasm() must be awaited first!");
4975 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
4976 return nativeResponseValue;
4978 // void RoutingMessageHandler_sync_routing_table LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
4980 export function RoutingMessageHandler_sync_routing_table(this_arg: number, their_node_id: number, init: number): void {
4981 if(!isWasmInitialized) {
4982 throw new Error("initializeWasm() must be awaited first!");
4984 const nativeResponseValue = wasm.TS_RoutingMessageHandler_sync_routing_table(this_arg, their_node_id, init);
4985 // debug statements here
4987 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
4989 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
4990 if(!isWasmInitialized) {
4991 throw new Error("initializeWasm() must be awaited first!");
4993 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
4994 return nativeResponseValue;
4996 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
4998 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
4999 if(!isWasmInitialized) {
5000 throw new Error("initializeWasm() must be awaited first!");
5002 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
5003 return nativeResponseValue;
5005 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
5007 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5008 if(!isWasmInitialized) {
5009 throw new Error("initializeWasm() must be awaited first!");
5011 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
5012 return nativeResponseValue;
5014 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
5016 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
5017 if(!isWasmInitialized) {
5018 throw new Error("initializeWasm() must be awaited first!");
5020 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
5021 return nativeResponseValue;
5024 export interface LDKCustomMessageReader {
5025 read (message_type: number, buffer: number): number;
5029 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
5030 if(!isWasmInitialized) {
5031 throw new Error("initializeWasm() must be awaited first!");
5033 var new_obj_idx = js_objs.length;
5034 for (var i = 0; i < js_objs.length; i++) {
5035 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5037 js_objs[i] = new WeakRef(impl);
5038 return wasm.TS_LDKCustomMessageReader_new(i);
5040 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
5042 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
5043 if(!isWasmInitialized) {
5044 throw new Error("initializeWasm() must be awaited first!");
5046 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
5047 return nativeResponseValue;
5050 export interface LDKCustomMessageHandler {
5051 handle_custom_message (msg: number, sender_node_id: number): number;
5052 get_and_clear_pending_msg (): number;
5056 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
5057 if(!isWasmInitialized) {
5058 throw new Error("initializeWasm() must be awaited first!");
5060 var new_obj_idx = js_objs.length;
5061 for (var i = 0; i < js_objs.length; i++) {
5062 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5064 js_objs[i] = new WeakRef(impl);
5065 return wasm.TS_LDKCustomMessageHandler_new(i);
5067 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
5069 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
5070 if(!isWasmInitialized) {
5071 throw new Error("initializeWasm() must be awaited first!");
5073 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
5074 return nativeResponseValue;
5076 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
5078 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
5079 if(!isWasmInitialized) {
5080 throw new Error("initializeWasm() must be awaited first!");
5082 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
5083 return nativeResponseValue;
5086 export interface LDKSocketDescriptor {
5087 send_data (data: number, resume_read: boolean): number;
5088 disconnect_socket (): void;
5089 eq (other_arg: number): boolean;
5094 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
5095 if(!isWasmInitialized) {
5096 throw new Error("initializeWasm() must be awaited first!");
5098 var new_obj_idx = js_objs.length;
5099 for (var i = 0; i < js_objs.length; i++) {
5100 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5102 js_objs[i] = new WeakRef(impl);
5103 return wasm.TS_LDKSocketDescriptor_new(i);
5105 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
5107 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
5108 if(!isWasmInitialized) {
5109 throw new Error("initializeWasm() must be awaited first!");
5111 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
5112 return nativeResponseValue;
5114 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
5116 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
5117 if(!isWasmInitialized) {
5118 throw new Error("initializeWasm() must be awaited first!");
5120 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
5121 // debug statements here
5123 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
5125 export function SocketDescriptor_hash(this_arg: number): bigint {
5126 if(!isWasmInitialized) {
5127 throw new Error("initializeWasm() must be awaited first!");
5129 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
5130 return nativeResponseValue;
5133 export interface LDKScore {
5134 channel_penalty_msat (short_channel_id: bigint, send_amt_msat: bigint, channel_capacity_msat: number, source: number, target: number): bigint;
5135 payment_path_failed (path: number, short_channel_id: bigint): void;
5136 payment_path_successful (path: number): void;
5141 export function LDKScore_new(impl: LDKScore): number {
5142 if(!isWasmInitialized) {
5143 throw new Error("initializeWasm() must be awaited first!");
5145 var new_obj_idx = js_objs.length;
5146 for (var i = 0; i < js_objs.length; i++) {
5147 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5149 js_objs[i] = new WeakRef(impl);
5150 return wasm.TS_LDKScore_new(i);
5152 // uint64_t Score_channel_penalty_msat LDKScore *NONNULL_PTR this_arg, uint64_t short_channel_id, uint64_t send_amt_msat, struct LDKCOption_u64Z channel_capacity_msat, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target
5154 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, send_amt_msat: bigint, channel_capacity_msat: number, source: number, target: number): bigint {
5155 if(!isWasmInitialized) {
5156 throw new Error("initializeWasm() must be awaited first!");
5158 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, send_amt_msat, channel_capacity_msat, source, target);
5159 return nativeResponseValue;
5161 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5163 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5164 if(!isWasmInitialized) {
5165 throw new Error("initializeWasm() must be awaited first!");
5167 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5168 // debug statements here
5170 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5172 export function Score_payment_path_successful(this_arg: number, path: number): void {
5173 if(!isWasmInitialized) {
5174 throw new Error("initializeWasm() must be awaited first!");
5176 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5177 // debug statements here
5179 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5181 export function Score_write(this_arg: number): number {
5182 if(!isWasmInitialized) {
5183 throw new Error("initializeWasm() must be awaited first!");
5185 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5186 return nativeResponseValue;
5189 export interface LDKLockableScore {
5194 export function LDKLockableScore_new(impl: LDKLockableScore): number {
5195 if(!isWasmInitialized) {
5196 throw new Error("initializeWasm() must be awaited first!");
5198 var new_obj_idx = js_objs.length;
5199 for (var i = 0; i < js_objs.length; i++) {
5200 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5202 js_objs[i] = new WeakRef(impl);
5203 return wasm.TS_LDKLockableScore_new(i);
5205 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
5207 export function LockableScore_lock(this_arg: number): number {
5208 if(!isWasmInitialized) {
5209 throw new Error("initializeWasm() must be awaited first!");
5211 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
5212 return nativeResponseValue;
5214 // struct LDKStr _ldk_get_compiled_version(void);
5216 export function _ldk_get_compiled_version(): number {
5217 if(!isWasmInitialized) {
5218 throw new Error("initializeWasm() must be awaited first!");
5220 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
5221 return nativeResponseValue;
5223 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
5225 export function _ldk_c_bindings_get_compiled_version(): number {
5226 if(!isWasmInitialized) {
5227 throw new Error("initializeWasm() must be awaited first!");
5229 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
5230 return nativeResponseValue;
5232 // void Transaction_free(struct LDKTransaction _res);
5234 export function Transaction_free(_res: number): void {
5235 if(!isWasmInitialized) {
5236 throw new Error("initializeWasm() must be awaited first!");
5238 const nativeResponseValue = wasm.TS_Transaction_free(_res);
5239 // debug statements here
5241 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
5243 export function TxOut_new(script_pubkey: number, value: bigint): number {
5244 if(!isWasmInitialized) {
5245 throw new Error("initializeWasm() must be awaited first!");
5247 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
5248 return nativeResponseValue;
5250 // void TxOut_free(struct LDKTxOut _res);
5252 export function TxOut_free(_res: number): void {
5253 if(!isWasmInitialized) {
5254 throw new Error("initializeWasm() must be awaited first!");
5256 const nativeResponseValue = wasm.TS_TxOut_free(_res);
5257 // debug statements here
5259 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
5261 export function TxOut_clone_ptr(arg: number): number {
5262 if(!isWasmInitialized) {
5263 throw new Error("initializeWasm() must be awaited first!");
5265 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
5266 return nativeResponseValue;
5268 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
5270 export function TxOut_clone(orig: number): number {
5271 if(!isWasmInitialized) {
5272 throw new Error("initializeWasm() must be awaited first!");
5274 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
5275 return nativeResponseValue;
5277 // void Str_free(struct LDKStr _res);
5279 export function Str_free(_res: number): void {
5280 if(!isWasmInitialized) {
5281 throw new Error("initializeWasm() must be awaited first!");
5283 const nativeResponseValue = wasm.TS_Str_free(_res);
5284 // debug statements here
5286 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
5288 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
5289 if(!isWasmInitialized) {
5290 throw new Error("initializeWasm() must be awaited first!");
5292 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
5293 return nativeResponseValue;
5295 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
5297 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
5298 if(!isWasmInitialized) {
5299 throw new Error("initializeWasm() must be awaited first!");
5301 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
5302 return nativeResponseValue;
5304 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
5306 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
5307 if(!isWasmInitialized) {
5308 throw new Error("initializeWasm() must be awaited first!");
5310 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
5311 return nativeResponseValue;
5313 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
5315 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
5316 if(!isWasmInitialized) {
5317 throw new Error("initializeWasm() must be awaited first!");
5319 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
5320 // debug statements here
5322 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
5324 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
5325 if(!isWasmInitialized) {
5326 throw new Error("initializeWasm() must be awaited first!");
5328 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
5329 return nativeResponseValue;
5331 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
5333 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
5334 if(!isWasmInitialized) {
5335 throw new Error("initializeWasm() must be awaited first!");
5337 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
5338 return nativeResponseValue;
5340 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
5342 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
5343 if(!isWasmInitialized) {
5344 throw new Error("initializeWasm() must be awaited first!");
5346 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
5347 return nativeResponseValue;
5349 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
5351 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
5352 if(!isWasmInitialized) {
5353 throw new Error("initializeWasm() must be awaited first!");
5355 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
5356 return nativeResponseValue;
5358 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
5360 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
5365 return nativeResponseValue;
5367 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
5369 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
5374 // debug statements here
5376 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
5378 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
5383 return nativeResponseValue;
5385 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
5387 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
5388 if(!isWasmInitialized) {
5389 throw new Error("initializeWasm() must be awaited first!");
5391 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
5392 return nativeResponseValue;
5394 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
5396 export function CResult_SecretKeyErrorZ_ok(o: number): number {
5397 if(!isWasmInitialized) {
5398 throw new Error("initializeWasm() must be awaited first!");
5400 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
5401 return nativeResponseValue;
5403 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
5405 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
5410 return nativeResponseValue;
5412 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
5414 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
5419 return nativeResponseValue;
5421 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
5423 export function CResult_SecretKeyErrorZ_free(_res: number): void {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
5428 // debug statements here
5430 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
5432 export function CResult_PublicKeyErrorZ_ok(o: number): number {
5433 if(!isWasmInitialized) {
5434 throw new Error("initializeWasm() must be awaited first!");
5436 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
5437 return nativeResponseValue;
5439 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
5441 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
5442 if(!isWasmInitialized) {
5443 throw new Error("initializeWasm() must be awaited first!");
5445 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
5446 return nativeResponseValue;
5448 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
5450 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
5451 if(!isWasmInitialized) {
5452 throw new Error("initializeWasm() must be awaited first!");
5454 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
5455 return nativeResponseValue;
5457 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
5459 export function CResult_PublicKeyErrorZ_free(_res: number): void {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
5464 // debug statements here
5466 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
5468 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
5469 if(!isWasmInitialized) {
5470 throw new Error("initializeWasm() must be awaited first!");
5472 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
5473 return nativeResponseValue;
5475 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
5477 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
5478 if(!isWasmInitialized) {
5479 throw new Error("initializeWasm() must be awaited first!");
5481 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
5482 return nativeResponseValue;
5484 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
5486 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
5487 if(!isWasmInitialized) {
5488 throw new Error("initializeWasm() must be awaited first!");
5490 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
5491 return nativeResponseValue;
5493 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
5495 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
5496 if(!isWasmInitialized) {
5497 throw new Error("initializeWasm() must be awaited first!");
5499 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
5500 return nativeResponseValue;
5502 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
5504 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
5509 return nativeResponseValue;
5511 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
5513 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
5514 if(!isWasmInitialized) {
5515 throw new Error("initializeWasm() must be awaited first!");
5517 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
5518 // debug statements here
5520 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
5522 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
5523 if(!isWasmInitialized) {
5524 throw new Error("initializeWasm() must be awaited first!");
5526 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
5527 return nativeResponseValue;
5529 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
5531 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
5532 if(!isWasmInitialized) {
5533 throw new Error("initializeWasm() must be awaited first!");
5535 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
5536 return nativeResponseValue;
5538 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
5540 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
5541 if(!isWasmInitialized) {
5542 throw new Error("initializeWasm() must be awaited first!");
5544 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
5545 return nativeResponseValue;
5547 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
5549 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
5550 if(!isWasmInitialized) {
5551 throw new Error("initializeWasm() must be awaited first!");
5553 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
5554 return nativeResponseValue;
5556 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
5558 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
5563 return nativeResponseValue;
5565 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
5567 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
5568 if(!isWasmInitialized) {
5569 throw new Error("initializeWasm() must be awaited first!");
5571 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
5572 // debug statements here
5574 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
5576 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
5577 if(!isWasmInitialized) {
5578 throw new Error("initializeWasm() must be awaited first!");
5580 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
5581 return nativeResponseValue;
5583 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
5585 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
5590 return nativeResponseValue;
5592 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
5594 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
5599 return nativeResponseValue;
5601 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
5603 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
5608 return nativeResponseValue;
5610 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
5612 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
5617 return nativeResponseValue;
5619 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
5621 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
5622 if(!isWasmInitialized) {
5623 throw new Error("initializeWasm() must be awaited first!");
5625 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
5626 // debug statements here
5628 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
5630 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
5631 if(!isWasmInitialized) {
5632 throw new Error("initializeWasm() must be awaited first!");
5634 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
5635 return nativeResponseValue;
5637 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
5639 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
5640 if(!isWasmInitialized) {
5641 throw new Error("initializeWasm() must be awaited first!");
5643 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
5644 return nativeResponseValue;
5646 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
5648 export function COption_u32Z_some(o: number): number {
5649 if(!isWasmInitialized) {
5650 throw new Error("initializeWasm() must be awaited first!");
5652 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
5653 return nativeResponseValue;
5655 // struct LDKCOption_u32Z COption_u32Z_none(void);
5657 export function COption_u32Z_none(): number {
5658 if(!isWasmInitialized) {
5659 throw new Error("initializeWasm() must be awaited first!");
5661 const nativeResponseValue = wasm.TS_COption_u32Z_none();
5662 return nativeResponseValue;
5664 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
5666 export function COption_u32Z_free(_res: number): void {
5667 if(!isWasmInitialized) {
5668 throw new Error("initializeWasm() must be awaited first!");
5670 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
5671 // debug statements here
5673 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
5675 export function COption_u32Z_clone_ptr(arg: number): number {
5676 if(!isWasmInitialized) {
5677 throw new Error("initializeWasm() must be awaited first!");
5679 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
5680 return nativeResponseValue;
5682 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
5684 export function COption_u32Z_clone(orig: number): number {
5685 if(!isWasmInitialized) {
5686 throw new Error("initializeWasm() must be awaited first!");
5688 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
5689 return nativeResponseValue;
5691 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
5693 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
5694 if(!isWasmInitialized) {
5695 throw new Error("initializeWasm() must be awaited first!");
5697 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
5698 return nativeResponseValue;
5700 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
5702 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
5703 if(!isWasmInitialized) {
5704 throw new Error("initializeWasm() must be awaited first!");
5706 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
5707 return nativeResponseValue;
5709 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
5711 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
5712 if(!isWasmInitialized) {
5713 throw new Error("initializeWasm() must be awaited first!");
5715 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
5716 return nativeResponseValue;
5718 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
5720 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
5721 if(!isWasmInitialized) {
5722 throw new Error("initializeWasm() must be awaited first!");
5724 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
5725 // debug statements here
5727 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
5729 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
5730 if(!isWasmInitialized) {
5731 throw new Error("initializeWasm() must be awaited first!");
5733 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
5734 return nativeResponseValue;
5736 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
5738 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
5739 if(!isWasmInitialized) {
5740 throw new Error("initializeWasm() must be awaited first!");
5742 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
5743 return nativeResponseValue;
5745 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
5747 export function COption_NoneZ_some(): COption_NoneZ {
5748 if(!isWasmInitialized) {
5749 throw new Error("initializeWasm() must be awaited first!");
5751 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
5752 return nativeResponseValue;
5754 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
5756 export function COption_NoneZ_none(): COption_NoneZ {
5757 if(!isWasmInitialized) {
5758 throw new Error("initializeWasm() must be awaited first!");
5760 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
5761 return nativeResponseValue;
5763 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
5765 export function COption_NoneZ_free(_res: COption_NoneZ): void {
5766 if(!isWasmInitialized) {
5767 throw new Error("initializeWasm() must be awaited first!");
5769 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
5770 // debug statements here
5772 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
5774 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
5775 if(!isWasmInitialized) {
5776 throw new Error("initializeWasm() must be awaited first!");
5778 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
5779 return nativeResponseValue;
5781 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5783 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
5784 if(!isWasmInitialized) {
5785 throw new Error("initializeWasm() must be awaited first!");
5787 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
5788 return nativeResponseValue;
5790 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
5792 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
5793 if(!isWasmInitialized) {
5794 throw new Error("initializeWasm() must be awaited first!");
5796 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
5797 return nativeResponseValue;
5799 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
5801 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
5806 // debug statements here
5808 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
5810 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
5815 return nativeResponseValue;
5817 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5819 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
5820 if(!isWasmInitialized) {
5821 throw new Error("initializeWasm() must be awaited first!");
5823 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
5824 return nativeResponseValue;
5826 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
5828 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
5833 return nativeResponseValue;
5835 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5837 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
5842 return nativeResponseValue;
5844 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
5846 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
5851 return nativeResponseValue;
5853 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
5855 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
5860 // debug statements here
5862 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
5864 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
5869 return nativeResponseValue;
5871 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5873 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
5878 return nativeResponseValue;
5880 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
5882 export function CVec_SignatureZ_free(_res: number): void {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
5887 // debug statements here
5889 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
5891 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
5896 return nativeResponseValue;
5898 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5900 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
5905 return nativeResponseValue;
5907 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
5909 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
5914 return nativeResponseValue;
5916 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
5918 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
5923 // debug statements here
5925 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
5927 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
5932 return nativeResponseValue;
5934 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5936 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
5941 return nativeResponseValue;
5943 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
5945 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
5950 return nativeResponseValue;
5952 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5954 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
5959 return nativeResponseValue;
5961 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
5963 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
5968 return nativeResponseValue;
5970 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
5972 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
5977 // debug statements here
5979 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
5981 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
5986 return nativeResponseValue;
5988 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5990 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
5995 return nativeResponseValue;
5997 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
5999 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
6004 return nativeResponseValue;
6006 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
6008 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
6013 return nativeResponseValue;
6015 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
6017 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
6022 return nativeResponseValue;
6024 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
6026 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
6031 // debug statements here
6033 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
6035 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
6040 return nativeResponseValue;
6042 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6044 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
6049 return nativeResponseValue;
6051 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6053 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
6058 return nativeResponseValue;
6060 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
6062 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
6063 if(!isWasmInitialized) {
6064 throw new Error("initializeWasm() must be awaited first!");
6066 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
6067 // debug statements here
6069 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6071 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6076 return nativeResponseValue;
6078 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6080 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6081 if(!isWasmInitialized) {
6082 throw new Error("initializeWasm() must be awaited first!");
6084 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
6085 return nativeResponseValue;
6087 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
6089 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
6094 return nativeResponseValue;
6096 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
6098 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
6099 if(!isWasmInitialized) {
6100 throw new Error("initializeWasm() must be awaited first!");
6102 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
6103 return nativeResponseValue;
6105 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
6107 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
6112 return nativeResponseValue;
6114 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
6116 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
6117 if(!isWasmInitialized) {
6118 throw new Error("initializeWasm() must be awaited first!");
6120 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
6121 // debug statements here
6123 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
6125 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
6130 return nativeResponseValue;
6132 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
6134 export function CResult_CVec_SignatureZNoneZ_err(): number {
6135 if(!isWasmInitialized) {
6136 throw new Error("initializeWasm() must be awaited first!");
6138 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
6139 return nativeResponseValue;
6141 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
6143 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
6144 if(!isWasmInitialized) {
6145 throw new Error("initializeWasm() must be awaited first!");
6147 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
6148 return nativeResponseValue;
6150 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
6152 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
6153 if(!isWasmInitialized) {
6154 throw new Error("initializeWasm() must be awaited first!");
6156 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
6157 // debug statements here
6159 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
6161 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
6162 if(!isWasmInitialized) {
6163 throw new Error("initializeWasm() must be awaited first!");
6165 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
6166 return nativeResponseValue;
6168 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
6170 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
6171 if(!isWasmInitialized) {
6172 throw new Error("initializeWasm() must be awaited first!");
6174 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
6175 return nativeResponseValue;
6177 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
6179 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
6180 if(!isWasmInitialized) {
6181 throw new Error("initializeWasm() must be awaited first!");
6183 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
6184 return nativeResponseValue;
6186 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
6188 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
6189 if(!isWasmInitialized) {
6190 throw new Error("initializeWasm() must be awaited first!");
6192 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
6193 return nativeResponseValue;
6195 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
6197 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
6198 if(!isWasmInitialized) {
6199 throw new Error("initializeWasm() must be awaited first!");
6201 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
6202 return nativeResponseValue;
6204 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
6206 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
6207 if(!isWasmInitialized) {
6208 throw new Error("initializeWasm() must be awaited first!");
6210 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
6211 // debug statements here
6213 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
6215 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
6216 if(!isWasmInitialized) {
6217 throw new Error("initializeWasm() must be awaited first!");
6219 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
6220 return nativeResponseValue;
6222 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
6224 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
6229 return nativeResponseValue;
6231 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
6233 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
6234 if(!isWasmInitialized) {
6235 throw new Error("initializeWasm() must be awaited first!");
6237 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
6238 return nativeResponseValue;
6240 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
6242 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
6247 return nativeResponseValue;
6249 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
6251 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
6252 if(!isWasmInitialized) {
6253 throw new Error("initializeWasm() must be awaited first!");
6255 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
6256 return nativeResponseValue;
6258 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
6260 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
6265 // debug statements here
6267 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
6269 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
6274 return nativeResponseValue;
6276 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
6278 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
6283 return nativeResponseValue;
6285 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
6287 export function COption_TypeZ_some(o: number): number {
6288 if(!isWasmInitialized) {
6289 throw new Error("initializeWasm() must be awaited first!");
6291 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
6292 return nativeResponseValue;
6294 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
6296 export function COption_TypeZ_none(): number {
6297 if(!isWasmInitialized) {
6298 throw new Error("initializeWasm() must be awaited first!");
6300 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
6301 return nativeResponseValue;
6303 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
6305 export function COption_TypeZ_free(_res: number): void {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
6310 // debug statements here
6312 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
6314 export function COption_TypeZ_clone_ptr(arg: number): number {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
6319 return nativeResponseValue;
6321 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
6323 export function COption_TypeZ_clone(orig: number): number {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
6328 return nativeResponseValue;
6330 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
6332 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
6337 return nativeResponseValue;
6339 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
6341 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
6342 if(!isWasmInitialized) {
6343 throw new Error("initializeWasm() must be awaited first!");
6345 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
6346 return nativeResponseValue;
6348 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
6350 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
6351 if(!isWasmInitialized) {
6352 throw new Error("initializeWasm() must be awaited first!");
6354 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
6355 return nativeResponseValue;
6357 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
6359 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
6360 if(!isWasmInitialized) {
6361 throw new Error("initializeWasm() must be awaited first!");
6363 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
6364 // debug statements here
6366 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
6368 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
6373 return nativeResponseValue;
6375 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
6377 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
6378 if(!isWasmInitialized) {
6379 throw new Error("initializeWasm() must be awaited first!");
6381 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
6382 return nativeResponseValue;
6384 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
6386 export function CResult_StringErrorZ_ok(o: number): number {
6387 if(!isWasmInitialized) {
6388 throw new Error("initializeWasm() must be awaited first!");
6390 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
6391 return nativeResponseValue;
6393 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
6395 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
6396 if(!isWasmInitialized) {
6397 throw new Error("initializeWasm() must be awaited first!");
6399 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
6400 return nativeResponseValue;
6402 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
6404 export function CResult_StringErrorZ_is_ok(o: number): boolean {
6405 if(!isWasmInitialized) {
6406 throw new Error("initializeWasm() must be awaited first!");
6408 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
6409 return nativeResponseValue;
6411 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
6413 export function CResult_StringErrorZ_free(_res: number): void {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
6418 // debug statements here
6420 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
6422 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
6423 if(!isWasmInitialized) {
6424 throw new Error("initializeWasm() must be awaited first!");
6426 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
6427 return nativeResponseValue;
6429 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
6431 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
6432 if(!isWasmInitialized) {
6433 throw new Error("initializeWasm() must be awaited first!");
6435 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
6436 return nativeResponseValue;
6438 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
6440 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
6441 if(!isWasmInitialized) {
6442 throw new Error("initializeWasm() must be awaited first!");
6444 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
6445 return nativeResponseValue;
6447 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
6449 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
6450 if(!isWasmInitialized) {
6451 throw new Error("initializeWasm() must be awaited first!");
6453 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
6454 // debug statements here
6456 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
6458 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
6459 if(!isWasmInitialized) {
6460 throw new Error("initializeWasm() must be awaited first!");
6462 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
6463 return nativeResponseValue;
6465 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
6467 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
6468 if(!isWasmInitialized) {
6469 throw new Error("initializeWasm() must be awaited first!");
6471 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
6472 return nativeResponseValue;
6474 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
6476 export function COption_MonitorEventZ_some(o: number): number {
6477 if(!isWasmInitialized) {
6478 throw new Error("initializeWasm() must be awaited first!");
6480 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
6481 return nativeResponseValue;
6483 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
6485 export function COption_MonitorEventZ_none(): number {
6486 if(!isWasmInitialized) {
6487 throw new Error("initializeWasm() must be awaited first!");
6489 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
6490 return nativeResponseValue;
6492 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
6494 export function COption_MonitorEventZ_free(_res: number): void {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
6499 // debug statements here
6501 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
6503 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
6504 if(!isWasmInitialized) {
6505 throw new Error("initializeWasm() must be awaited first!");
6507 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
6508 return nativeResponseValue;
6510 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
6512 export function COption_MonitorEventZ_clone(orig: number): number {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
6517 return nativeResponseValue;
6519 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
6521 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
6526 return nativeResponseValue;
6528 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
6530 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
6535 return nativeResponseValue;
6537 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
6539 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
6544 return nativeResponseValue;
6546 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
6548 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
6553 // debug statements here
6555 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
6557 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
6562 return nativeResponseValue;
6564 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
6566 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
6571 return nativeResponseValue;
6573 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
6575 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
6580 return nativeResponseValue;
6582 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
6584 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
6589 return nativeResponseValue;
6591 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
6593 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
6598 return nativeResponseValue;
6600 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
6602 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
6603 if(!isWasmInitialized) {
6604 throw new Error("initializeWasm() must be awaited first!");
6606 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
6607 // debug statements here
6609 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
6611 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
6616 return nativeResponseValue;
6618 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
6620 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
6621 if(!isWasmInitialized) {
6622 throw new Error("initializeWasm() must be awaited first!");
6624 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
6625 return nativeResponseValue;
6627 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6629 export function CResult_NoneNoneZ_ok(): number {
6630 if(!isWasmInitialized) {
6631 throw new Error("initializeWasm() must be awaited first!");
6633 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6634 return nativeResponseValue;
6636 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6638 export function CResult_NoneNoneZ_err(): number {
6639 if(!isWasmInitialized) {
6640 throw new Error("initializeWasm() must be awaited first!");
6642 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6643 return nativeResponseValue;
6645 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6647 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6648 if(!isWasmInitialized) {
6649 throw new Error("initializeWasm() must be awaited first!");
6651 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6652 return nativeResponseValue;
6654 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6656 export function CResult_NoneNoneZ_free(_res: number): void {
6657 if(!isWasmInitialized) {
6658 throw new Error("initializeWasm() must be awaited first!");
6660 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6661 // debug statements here
6663 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6665 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6666 if(!isWasmInitialized) {
6667 throw new Error("initializeWasm() must be awaited first!");
6669 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6670 return nativeResponseValue;
6672 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6674 export function CResult_NoneNoneZ_clone(orig: number): number {
6675 if(!isWasmInitialized) {
6676 throw new Error("initializeWasm() must be awaited first!");
6678 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6679 return nativeResponseValue;
6681 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
6683 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
6684 if(!isWasmInitialized) {
6685 throw new Error("initializeWasm() must be awaited first!");
6687 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
6688 return nativeResponseValue;
6690 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
6692 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
6693 if(!isWasmInitialized) {
6694 throw new Error("initializeWasm() must be awaited first!");
6696 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
6697 // debug statements here
6699 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
6701 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
6702 if(!isWasmInitialized) {
6703 throw new Error("initializeWasm() must be awaited first!");
6705 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
6706 return nativeResponseValue;
6708 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
6710 export function C2Tuple_u32ScriptZ_free(_res: number): void {
6711 if(!isWasmInitialized) {
6712 throw new Error("initializeWasm() must be awaited first!");
6714 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
6715 // debug statements here
6717 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
6719 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
6720 if(!isWasmInitialized) {
6721 throw new Error("initializeWasm() must be awaited first!");
6723 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
6724 // debug statements here
6726 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
6728 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
6729 if(!isWasmInitialized) {
6730 throw new Error("initializeWasm() must be awaited first!");
6732 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
6733 return nativeResponseValue;
6735 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
6737 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
6738 if(!isWasmInitialized) {
6739 throw new Error("initializeWasm() must be awaited first!");
6741 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
6742 // debug statements here
6744 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
6746 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
6747 if(!isWasmInitialized) {
6748 throw new Error("initializeWasm() must be awaited first!");
6750 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
6751 // debug statements here
6753 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
6755 export function CVec_MonitorEventZ_free(_res: number): void {
6756 if(!isWasmInitialized) {
6757 throw new Error("initializeWasm() must be awaited first!");
6759 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
6760 // debug statements here
6762 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
6764 export function CVec_EventZ_free(_res: number): void {
6765 if(!isWasmInitialized) {
6766 throw new Error("initializeWasm() must be awaited first!");
6768 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
6769 // debug statements here
6771 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
6773 export function CVec_TransactionZ_free(_res: number): void {
6774 if(!isWasmInitialized) {
6775 throw new Error("initializeWasm() must be awaited first!");
6777 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
6778 // debug statements here
6780 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
6782 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
6783 if(!isWasmInitialized) {
6784 throw new Error("initializeWasm() must be awaited first!");
6786 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
6787 return nativeResponseValue;
6789 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
6791 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
6792 if(!isWasmInitialized) {
6793 throw new Error("initializeWasm() must be awaited first!");
6795 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
6796 return nativeResponseValue;
6798 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
6800 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
6801 if(!isWasmInitialized) {
6802 throw new Error("initializeWasm() must be awaited first!");
6804 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
6805 return nativeResponseValue;
6807 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
6809 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
6810 if(!isWasmInitialized) {
6811 throw new Error("initializeWasm() must be awaited first!");
6813 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
6814 // debug statements here
6816 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
6818 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
6819 if(!isWasmInitialized) {
6820 throw new Error("initializeWasm() must be awaited first!");
6822 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
6823 // debug statements here
6825 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
6827 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
6828 if(!isWasmInitialized) {
6829 throw new Error("initializeWasm() must be awaited first!");
6831 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
6832 return nativeResponseValue;
6834 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
6836 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
6837 if(!isWasmInitialized) {
6838 throw new Error("initializeWasm() must be awaited first!");
6840 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
6841 return nativeResponseValue;
6843 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
6845 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
6846 if(!isWasmInitialized) {
6847 throw new Error("initializeWasm() must be awaited first!");
6849 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
6850 return nativeResponseValue;
6852 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
6854 export function C2Tuple_u32TxOutZ_free(_res: number): void {
6855 if(!isWasmInitialized) {
6856 throw new Error("initializeWasm() must be awaited first!");
6858 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
6859 // debug statements here
6861 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
6863 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
6864 if(!isWasmInitialized) {
6865 throw new Error("initializeWasm() must be awaited first!");
6867 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
6868 // debug statements here
6870 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
6872 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
6873 if(!isWasmInitialized) {
6874 throw new Error("initializeWasm() must be awaited first!");
6876 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
6877 return nativeResponseValue;
6879 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
6881 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
6882 if(!isWasmInitialized) {
6883 throw new Error("initializeWasm() must be awaited first!");
6885 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
6886 return nativeResponseValue;
6888 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
6890 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
6891 if(!isWasmInitialized) {
6892 throw new Error("initializeWasm() must be awaited first!");
6894 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
6895 return nativeResponseValue;
6897 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
6899 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
6900 if(!isWasmInitialized) {
6901 throw new Error("initializeWasm() must be awaited first!");
6903 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
6904 // debug statements here
6906 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
6908 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
6909 if(!isWasmInitialized) {
6910 throw new Error("initializeWasm() must be awaited first!");
6912 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
6913 // debug statements here
6915 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
6917 export function CVec_TxidZ_free(_res: number): void {
6918 if(!isWasmInitialized) {
6919 throw new Error("initializeWasm() must be awaited first!");
6921 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
6922 // debug statements here
6924 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
6926 export function CVec_BalanceZ_free(_res: number): void {
6927 if(!isWasmInitialized) {
6928 throw new Error("initializeWasm() must be awaited first!");
6930 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
6931 // debug statements here
6933 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
6935 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
6936 if(!isWasmInitialized) {
6937 throw new Error("initializeWasm() must be awaited first!");
6939 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
6940 return nativeResponseValue;
6942 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
6944 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
6945 if(!isWasmInitialized) {
6946 throw new Error("initializeWasm() must be awaited first!");
6948 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
6949 return nativeResponseValue;
6951 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
6953 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
6954 if(!isWasmInitialized) {
6955 throw new Error("initializeWasm() must be awaited first!");
6957 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
6958 return nativeResponseValue;
6960 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
6962 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
6963 if(!isWasmInitialized) {
6964 throw new Error("initializeWasm() must be awaited first!");
6966 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
6967 // debug statements here
6969 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
6971 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
6972 if(!isWasmInitialized) {
6973 throw new Error("initializeWasm() must be awaited first!");
6975 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
6976 return nativeResponseValue;
6978 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
6980 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
6981 if(!isWasmInitialized) {
6982 throw new Error("initializeWasm() must be awaited first!");
6984 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
6985 return nativeResponseValue;
6987 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
6989 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
6990 if(!isWasmInitialized) {
6991 throw new Error("initializeWasm() must be awaited first!");
6993 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
6994 return nativeResponseValue;
6996 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
6998 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
6999 if(!isWasmInitialized) {
7000 throw new Error("initializeWasm() must be awaited first!");
7002 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
7003 // debug statements here
7005 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
7007 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
7008 if(!isWasmInitialized) {
7009 throw new Error("initializeWasm() must be awaited first!");
7011 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
7012 return nativeResponseValue;
7014 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
7016 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
7017 if(!isWasmInitialized) {
7018 throw new Error("initializeWasm() must be awaited first!");
7020 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
7021 return nativeResponseValue;
7023 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7025 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7026 if(!isWasmInitialized) {
7027 throw new Error("initializeWasm() must be awaited first!");
7029 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7030 return nativeResponseValue;
7032 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7034 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7035 if(!isWasmInitialized) {
7036 throw new Error("initializeWasm() must be awaited first!");
7038 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7039 return nativeResponseValue;
7041 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7043 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7044 if(!isWasmInitialized) {
7045 throw new Error("initializeWasm() must be awaited first!");
7047 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7048 return nativeResponseValue;
7050 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7052 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7053 if(!isWasmInitialized) {
7054 throw new Error("initializeWasm() must be awaited first!");
7056 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7057 // debug statements here
7059 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7061 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7062 if(!isWasmInitialized) {
7063 throw new Error("initializeWasm() must be awaited first!");
7065 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7066 return nativeResponseValue;
7068 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7070 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7071 if(!isWasmInitialized) {
7072 throw new Error("initializeWasm() must be awaited first!");
7074 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7075 return nativeResponseValue;
7077 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7079 export function CVec_RouteHopZ_free(_res: number): void {
7080 if(!isWasmInitialized) {
7081 throw new Error("initializeWasm() must be awaited first!");
7083 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7084 // debug statements here
7086 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7088 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7089 if(!isWasmInitialized) {
7090 throw new Error("initializeWasm() must be awaited first!");
7092 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7093 // debug statements here
7095 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7097 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7098 if(!isWasmInitialized) {
7099 throw new Error("initializeWasm() must be awaited first!");
7101 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7102 return nativeResponseValue;
7104 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7106 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7107 if(!isWasmInitialized) {
7108 throw new Error("initializeWasm() must be awaited first!");
7110 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7111 return nativeResponseValue;
7113 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7115 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7116 if(!isWasmInitialized) {
7117 throw new Error("initializeWasm() must be awaited first!");
7119 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7120 return nativeResponseValue;
7122 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7124 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7125 if(!isWasmInitialized) {
7126 throw new Error("initializeWasm() must be awaited first!");
7128 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7129 // debug statements here
7131 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7133 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7134 if(!isWasmInitialized) {
7135 throw new Error("initializeWasm() must be awaited first!");
7137 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7138 return nativeResponseValue;
7140 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7142 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7143 if(!isWasmInitialized) {
7144 throw new Error("initializeWasm() must be awaited first!");
7146 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7147 return nativeResponseValue;
7149 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7151 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7152 if(!isWasmInitialized) {
7153 throw new Error("initializeWasm() must be awaited first!");
7155 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7156 return nativeResponseValue;
7158 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7160 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7161 if(!isWasmInitialized) {
7162 throw new Error("initializeWasm() must be awaited first!");
7164 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7165 return nativeResponseValue;
7167 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7169 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7170 if(!isWasmInitialized) {
7171 throw new Error("initializeWasm() must be awaited first!");
7173 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7174 return nativeResponseValue;
7176 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7178 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7179 if(!isWasmInitialized) {
7180 throw new Error("initializeWasm() must be awaited first!");
7182 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7183 // debug statements here
7185 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7187 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7188 if(!isWasmInitialized) {
7189 throw new Error("initializeWasm() must be awaited first!");
7191 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7192 return nativeResponseValue;
7194 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7196 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7197 if(!isWasmInitialized) {
7198 throw new Error("initializeWasm() must be awaited first!");
7200 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7201 return nativeResponseValue;
7203 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7205 export function CVec_RouteHintZ_free(_res: number): void {
7206 if(!isWasmInitialized) {
7207 throw new Error("initializeWasm() must be awaited first!");
7209 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7210 // debug statements here
7212 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7214 export function COption_u64Z_some(o: bigint): number {
7215 if(!isWasmInitialized) {
7216 throw new Error("initializeWasm() must be awaited first!");
7218 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7219 return nativeResponseValue;
7221 // struct LDKCOption_u64Z COption_u64Z_none(void);
7223 export function COption_u64Z_none(): number {
7224 if(!isWasmInitialized) {
7225 throw new Error("initializeWasm() must be awaited first!");
7227 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7228 return nativeResponseValue;
7230 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7232 export function COption_u64Z_free(_res: number): void {
7233 if(!isWasmInitialized) {
7234 throw new Error("initializeWasm() must be awaited first!");
7236 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7237 // debug statements here
7239 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7241 export function COption_u64Z_clone_ptr(arg: number): number {
7242 if(!isWasmInitialized) {
7243 throw new Error("initializeWasm() must be awaited first!");
7245 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7246 return nativeResponseValue;
7248 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7250 export function COption_u64Z_clone(orig: number): number {
7251 if(!isWasmInitialized) {
7252 throw new Error("initializeWasm() must be awaited first!");
7254 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7255 return nativeResponseValue;
7257 // struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_ok(struct LDKPayee o);
7259 export function CResult_PayeeDecodeErrorZ_ok(o: number): number {
7260 if(!isWasmInitialized) {
7261 throw new Error("initializeWasm() must be awaited first!");
7263 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_ok(o);
7264 return nativeResponseValue;
7266 // struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_err(struct LDKDecodeError e);
7268 export function CResult_PayeeDecodeErrorZ_err(e: number): number {
7269 if(!isWasmInitialized) {
7270 throw new Error("initializeWasm() must be awaited first!");
7272 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_err(e);
7273 return nativeResponseValue;
7275 // bool CResult_PayeeDecodeErrorZ_is_ok(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR o);
7277 export function CResult_PayeeDecodeErrorZ_is_ok(o: number): boolean {
7278 if(!isWasmInitialized) {
7279 throw new Error("initializeWasm() must be awaited first!");
7281 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_is_ok(o);
7282 return nativeResponseValue;
7284 // void CResult_PayeeDecodeErrorZ_free(struct LDKCResult_PayeeDecodeErrorZ _res);
7286 export function CResult_PayeeDecodeErrorZ_free(_res: number): void {
7287 if(!isWasmInitialized) {
7288 throw new Error("initializeWasm() must be awaited first!");
7290 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_free(_res);
7291 // debug statements here
7293 // uintptr_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg);
7295 export function CResult_PayeeDecodeErrorZ_clone_ptr(arg: number): number {
7296 if(!isWasmInitialized) {
7297 throw new Error("initializeWasm() must be awaited first!");
7299 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_clone_ptr(arg);
7300 return nativeResponseValue;
7302 // struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_clone(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR orig);
7304 export function CResult_PayeeDecodeErrorZ_clone(orig: number): number {
7305 if(!isWasmInitialized) {
7306 throw new Error("initializeWasm() must be awaited first!");
7308 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_clone(orig);
7309 return nativeResponseValue;
7311 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7313 export function CVec_RouteHintHopZ_free(_res: number): void {
7314 if(!isWasmInitialized) {
7315 throw new Error("initializeWasm() must be awaited first!");
7317 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7318 // debug statements here
7320 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7322 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7323 if(!isWasmInitialized) {
7324 throw new Error("initializeWasm() must be awaited first!");
7326 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7327 return nativeResponseValue;
7329 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7331 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7332 if(!isWasmInitialized) {
7333 throw new Error("initializeWasm() must be awaited first!");
7335 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7336 return nativeResponseValue;
7338 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7340 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7341 if(!isWasmInitialized) {
7342 throw new Error("initializeWasm() must be awaited first!");
7344 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7345 return nativeResponseValue;
7347 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7349 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7350 if(!isWasmInitialized) {
7351 throw new Error("initializeWasm() must be awaited first!");
7353 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7354 // debug statements here
7356 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7358 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7359 if(!isWasmInitialized) {
7360 throw new Error("initializeWasm() must be awaited first!");
7362 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7363 return nativeResponseValue;
7365 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7367 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7368 if(!isWasmInitialized) {
7369 throw new Error("initializeWasm() must be awaited first!");
7371 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7372 return nativeResponseValue;
7374 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7376 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7377 if(!isWasmInitialized) {
7378 throw new Error("initializeWasm() must be awaited first!");
7380 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7381 return nativeResponseValue;
7383 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7385 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7390 return nativeResponseValue;
7392 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7394 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7395 if(!isWasmInitialized) {
7396 throw new Error("initializeWasm() must be awaited first!");
7398 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7399 return nativeResponseValue;
7401 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7403 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7404 if(!isWasmInitialized) {
7405 throw new Error("initializeWasm() must be awaited first!");
7407 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7408 // debug statements here
7410 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7412 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7413 if(!isWasmInitialized) {
7414 throw new Error("initializeWasm() must be awaited first!");
7416 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7417 return nativeResponseValue;
7419 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7421 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7426 return nativeResponseValue;
7428 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7430 export function CVec_ChannelDetailsZ_free(_res: number): void {
7431 if(!isWasmInitialized) {
7432 throw new Error("initializeWasm() must be awaited first!");
7434 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7435 // debug statements here
7437 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7439 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7440 if(!isWasmInitialized) {
7441 throw new Error("initializeWasm() must be awaited first!");
7443 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7444 return nativeResponseValue;
7446 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7448 export function CResult_RouteLightningErrorZ_err(e: number): number {
7449 if(!isWasmInitialized) {
7450 throw new Error("initializeWasm() must be awaited first!");
7452 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7453 return nativeResponseValue;
7455 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7457 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7458 if(!isWasmInitialized) {
7459 throw new Error("initializeWasm() must be awaited first!");
7461 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7462 return nativeResponseValue;
7464 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7466 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7467 if(!isWasmInitialized) {
7468 throw new Error("initializeWasm() must be awaited first!");
7470 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7471 // debug statements here
7473 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7475 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7476 if(!isWasmInitialized) {
7477 throw new Error("initializeWasm() must be awaited first!");
7479 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
7480 return nativeResponseValue;
7482 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
7484 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
7485 if(!isWasmInitialized) {
7486 throw new Error("initializeWasm() must be awaited first!");
7488 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
7489 return nativeResponseValue;
7491 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
7493 export function CResult_NoneLightningErrorZ_ok(): number {
7494 if(!isWasmInitialized) {
7495 throw new Error("initializeWasm() must be awaited first!");
7497 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
7498 return nativeResponseValue;
7500 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
7502 export function CResult_NoneLightningErrorZ_err(e: number): number {
7503 if(!isWasmInitialized) {
7504 throw new Error("initializeWasm() must be awaited first!");
7506 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
7507 return nativeResponseValue;
7509 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
7511 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
7512 if(!isWasmInitialized) {
7513 throw new Error("initializeWasm() must be awaited first!");
7515 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
7516 return nativeResponseValue;
7518 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
7520 export function CResult_NoneLightningErrorZ_free(_res: number): void {
7521 if(!isWasmInitialized) {
7522 throw new Error("initializeWasm() must be awaited first!");
7524 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
7525 // debug statements here
7527 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
7529 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
7530 if(!isWasmInitialized) {
7531 throw new Error("initializeWasm() must be awaited first!");
7533 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
7534 return nativeResponseValue;
7536 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
7538 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
7539 if(!isWasmInitialized) {
7540 throw new Error("initializeWasm() must be awaited first!");
7542 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
7543 return nativeResponseValue;
7545 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
7547 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
7548 if(!isWasmInitialized) {
7549 throw new Error("initializeWasm() must be awaited first!");
7551 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
7552 return nativeResponseValue;
7554 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
7556 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
7557 if(!isWasmInitialized) {
7558 throw new Error("initializeWasm() must be awaited first!");
7560 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
7561 return nativeResponseValue;
7563 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
7565 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
7566 if(!isWasmInitialized) {
7567 throw new Error("initializeWasm() must be awaited first!");
7569 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
7570 return nativeResponseValue;
7572 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
7574 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
7575 if(!isWasmInitialized) {
7576 throw new Error("initializeWasm() must be awaited first!");
7578 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
7579 // debug statements here
7581 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
7583 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
7584 if(!isWasmInitialized) {
7585 throw new Error("initializeWasm() must be awaited first!");
7587 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
7588 // debug statements here
7590 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
7592 export function CVec_MessageSendEventZ_free(_res: number): void {
7593 if(!isWasmInitialized) {
7594 throw new Error("initializeWasm() must be awaited first!");
7596 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
7597 // debug statements here
7599 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
7601 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
7602 if(!isWasmInitialized) {
7603 throw new Error("initializeWasm() must be awaited first!");
7605 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
7606 return nativeResponseValue;
7608 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
7610 export function CResult_boolLightningErrorZ_err(e: number): number {
7611 if(!isWasmInitialized) {
7612 throw new Error("initializeWasm() must be awaited first!");
7614 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
7615 return nativeResponseValue;
7617 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
7619 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
7620 if(!isWasmInitialized) {
7621 throw new Error("initializeWasm() must be awaited first!");
7623 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
7624 return nativeResponseValue;
7626 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
7628 export function CResult_boolLightningErrorZ_free(_res: number): void {
7629 if(!isWasmInitialized) {
7630 throw new Error("initializeWasm() must be awaited first!");
7632 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
7633 // debug statements here
7635 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
7637 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
7638 if(!isWasmInitialized) {
7639 throw new Error("initializeWasm() must be awaited first!");
7641 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
7642 return nativeResponseValue;
7644 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
7646 export function CResult_boolLightningErrorZ_clone(orig: number): number {
7647 if(!isWasmInitialized) {
7648 throw new Error("initializeWasm() must be awaited first!");
7650 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
7651 return nativeResponseValue;
7653 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
7655 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
7656 if(!isWasmInitialized) {
7657 throw new Error("initializeWasm() must be awaited first!");
7659 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
7660 return nativeResponseValue;
7662 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
7664 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
7665 if(!isWasmInitialized) {
7666 throw new Error("initializeWasm() must be awaited first!");
7668 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
7669 return nativeResponseValue;
7671 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
7673 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
7674 if(!isWasmInitialized) {
7675 throw new Error("initializeWasm() must be awaited first!");
7677 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
7678 return nativeResponseValue;
7680 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
7682 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
7683 if(!isWasmInitialized) {
7684 throw new Error("initializeWasm() must be awaited first!");
7686 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
7687 // debug statements here
7689 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
7691 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
7692 if(!isWasmInitialized) {
7693 throw new Error("initializeWasm() must be awaited first!");
7695 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
7696 // debug statements here
7698 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
7700 export function CVec_NodeAnnouncementZ_free(_res: number): void {
7701 if(!isWasmInitialized) {
7702 throw new Error("initializeWasm() must be awaited first!");
7704 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
7705 // debug statements here
7707 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
7709 export function CVec_PublicKeyZ_free(_res: number): void {
7710 if(!isWasmInitialized) {
7711 throw new Error("initializeWasm() must be awaited first!");
7713 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
7714 // debug statements here
7716 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
7718 export function CVec_u8Z_free(_res: number): void {
7719 if(!isWasmInitialized) {
7720 throw new Error("initializeWasm() must be awaited first!");
7722 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
7723 // debug statements here
7725 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
7727 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
7728 if(!isWasmInitialized) {
7729 throw new Error("initializeWasm() must be awaited first!");
7731 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
7732 return nativeResponseValue;
7734 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
7736 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
7737 if(!isWasmInitialized) {
7738 throw new Error("initializeWasm() must be awaited first!");
7740 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
7741 return nativeResponseValue;
7743 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
7745 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
7746 if(!isWasmInitialized) {
7747 throw new Error("initializeWasm() must be awaited first!");
7749 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
7750 return nativeResponseValue;
7752 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
7754 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
7755 if(!isWasmInitialized) {
7756 throw new Error("initializeWasm() must be awaited first!");
7758 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
7759 // debug statements here
7761 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
7763 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
7764 if(!isWasmInitialized) {
7765 throw new Error("initializeWasm() must be awaited first!");
7767 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
7768 return nativeResponseValue;
7770 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
7772 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
7773 if(!isWasmInitialized) {
7774 throw new Error("initializeWasm() must be awaited first!");
7776 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
7777 return nativeResponseValue;
7779 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
7781 export function CResult_NonePeerHandleErrorZ_ok(): number {
7782 if(!isWasmInitialized) {
7783 throw new Error("initializeWasm() must be awaited first!");
7785 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
7786 return nativeResponseValue;
7788 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
7790 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
7791 if(!isWasmInitialized) {
7792 throw new Error("initializeWasm() must be awaited first!");
7794 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
7795 return nativeResponseValue;
7797 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
7799 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
7800 if(!isWasmInitialized) {
7801 throw new Error("initializeWasm() must be awaited first!");
7803 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
7804 return nativeResponseValue;
7806 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
7808 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
7809 if(!isWasmInitialized) {
7810 throw new Error("initializeWasm() must be awaited first!");
7812 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
7813 // debug statements here
7815 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
7817 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
7818 if(!isWasmInitialized) {
7819 throw new Error("initializeWasm() must be awaited first!");
7821 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
7822 return nativeResponseValue;
7824 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
7826 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
7827 if(!isWasmInitialized) {
7828 throw new Error("initializeWasm() must be awaited first!");
7830 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
7831 return nativeResponseValue;
7833 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
7835 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
7836 if(!isWasmInitialized) {
7837 throw new Error("initializeWasm() must be awaited first!");
7839 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
7840 return nativeResponseValue;
7842 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
7844 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
7845 if(!isWasmInitialized) {
7846 throw new Error("initializeWasm() must be awaited first!");
7848 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
7849 return nativeResponseValue;
7851 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
7853 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
7854 if(!isWasmInitialized) {
7855 throw new Error("initializeWasm() must be awaited first!");
7857 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
7858 return nativeResponseValue;
7860 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
7862 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
7863 if(!isWasmInitialized) {
7864 throw new Error("initializeWasm() must be awaited first!");
7866 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
7867 // debug statements here
7869 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
7871 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
7872 if(!isWasmInitialized) {
7873 throw new Error("initializeWasm() must be awaited first!");
7875 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
7876 return nativeResponseValue;
7878 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
7880 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
7881 if(!isWasmInitialized) {
7882 throw new Error("initializeWasm() must be awaited first!");
7884 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
7885 return nativeResponseValue;
7887 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
7889 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
7890 if(!isWasmInitialized) {
7891 throw new Error("initializeWasm() must be awaited first!");
7893 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
7894 return nativeResponseValue;
7896 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
7898 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
7899 if(!isWasmInitialized) {
7900 throw new Error("initializeWasm() must be awaited first!");
7902 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
7903 return nativeResponseValue;
7905 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
7907 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
7908 if(!isWasmInitialized) {
7909 throw new Error("initializeWasm() must be awaited first!");
7911 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
7912 return nativeResponseValue;
7914 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
7916 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
7917 if(!isWasmInitialized) {
7918 throw new Error("initializeWasm() must be awaited first!");
7920 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
7921 // debug statements here
7923 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
7925 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
7926 if(!isWasmInitialized) {
7927 throw new Error("initializeWasm() must be awaited first!");
7929 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
7930 return nativeResponseValue;
7932 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
7934 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
7935 if(!isWasmInitialized) {
7936 throw new Error("initializeWasm() must be awaited first!");
7938 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
7939 return nativeResponseValue;
7941 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
7943 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
7944 if(!isWasmInitialized) {
7945 throw new Error("initializeWasm() must be awaited first!");
7947 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
7948 return nativeResponseValue;
7950 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
7952 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
7953 if(!isWasmInitialized) {
7954 throw new Error("initializeWasm() must be awaited first!");
7956 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
7957 return nativeResponseValue;
7959 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
7961 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
7962 if(!isWasmInitialized) {
7963 throw new Error("initializeWasm() must be awaited first!");
7965 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
7966 return nativeResponseValue;
7968 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
7970 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
7971 if(!isWasmInitialized) {
7972 throw new Error("initializeWasm() must be awaited first!");
7974 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
7975 // debug statements here
7977 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
7979 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
7980 if(!isWasmInitialized) {
7981 throw new Error("initializeWasm() must be awaited first!");
7983 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
7984 return nativeResponseValue;
7986 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
7988 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
7989 if(!isWasmInitialized) {
7990 throw new Error("initializeWasm() must be awaited first!");
7992 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
7993 return nativeResponseValue;
7995 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
7997 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
7998 if(!isWasmInitialized) {
7999 throw new Error("initializeWasm() must be awaited first!");
8001 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8002 return nativeResponseValue;
8004 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8006 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8007 if(!isWasmInitialized) {
8008 throw new Error("initializeWasm() must be awaited first!");
8010 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8011 return nativeResponseValue;
8013 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8015 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8016 if(!isWasmInitialized) {
8017 throw new Error("initializeWasm() must be awaited first!");
8019 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8020 // debug statements here
8022 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8024 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8025 if(!isWasmInitialized) {
8026 throw new Error("initializeWasm() must be awaited first!");
8028 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8029 return nativeResponseValue;
8031 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8033 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8034 if(!isWasmInitialized) {
8035 throw new Error("initializeWasm() must be awaited first!");
8037 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8038 return nativeResponseValue;
8040 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8042 export function COption_ClosureReasonZ_some(o: number): number {
8043 if(!isWasmInitialized) {
8044 throw new Error("initializeWasm() must be awaited first!");
8046 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8047 return nativeResponseValue;
8049 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8051 export function COption_ClosureReasonZ_none(): number {
8052 if(!isWasmInitialized) {
8053 throw new Error("initializeWasm() must be awaited first!");
8055 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8056 return nativeResponseValue;
8058 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8060 export function COption_ClosureReasonZ_free(_res: number): void {
8061 if(!isWasmInitialized) {
8062 throw new Error("initializeWasm() must be awaited first!");
8064 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8065 // debug statements here
8067 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8069 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8070 if(!isWasmInitialized) {
8071 throw new Error("initializeWasm() must be awaited first!");
8073 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8074 return nativeResponseValue;
8076 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8078 export function COption_ClosureReasonZ_clone(orig: number): number {
8079 if(!isWasmInitialized) {
8080 throw new Error("initializeWasm() must be awaited first!");
8082 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8083 return nativeResponseValue;
8085 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8087 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8088 if(!isWasmInitialized) {
8089 throw new Error("initializeWasm() must be awaited first!");
8091 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8092 return nativeResponseValue;
8094 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8096 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8097 if(!isWasmInitialized) {
8098 throw new Error("initializeWasm() must be awaited first!");
8100 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8101 return nativeResponseValue;
8103 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8105 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8106 if(!isWasmInitialized) {
8107 throw new Error("initializeWasm() must be awaited first!");
8109 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8110 return nativeResponseValue;
8112 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8114 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8115 if(!isWasmInitialized) {
8116 throw new Error("initializeWasm() must be awaited first!");
8118 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8119 // debug statements here
8121 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8123 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8124 if(!isWasmInitialized) {
8125 throw new Error("initializeWasm() must be awaited first!");
8127 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8128 return nativeResponseValue;
8130 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8132 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8133 if(!isWasmInitialized) {
8134 throw new Error("initializeWasm() must be awaited first!");
8136 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8137 return nativeResponseValue;
8139 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8141 export function COption_NetworkUpdateZ_some(o: number): number {
8142 if(!isWasmInitialized) {
8143 throw new Error("initializeWasm() must be awaited first!");
8145 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8146 return nativeResponseValue;
8148 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8150 export function COption_NetworkUpdateZ_none(): number {
8151 if(!isWasmInitialized) {
8152 throw new Error("initializeWasm() must be awaited first!");
8154 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8155 return nativeResponseValue;
8157 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8159 export function COption_NetworkUpdateZ_free(_res: number): void {
8160 if(!isWasmInitialized) {
8161 throw new Error("initializeWasm() must be awaited first!");
8163 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8164 // debug statements here
8166 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8168 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8169 if(!isWasmInitialized) {
8170 throw new Error("initializeWasm() must be awaited first!");
8172 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8173 return nativeResponseValue;
8175 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8177 export function COption_NetworkUpdateZ_clone(orig: number): number {
8178 if(!isWasmInitialized) {
8179 throw new Error("initializeWasm() must be awaited first!");
8181 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8182 return nativeResponseValue;
8184 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8186 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8187 if(!isWasmInitialized) {
8188 throw new Error("initializeWasm() must be awaited first!");
8190 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8191 // debug statements here
8193 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8195 export function COption_EventZ_some(o: number): number {
8196 if(!isWasmInitialized) {
8197 throw new Error("initializeWasm() must be awaited first!");
8199 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8200 return nativeResponseValue;
8202 // struct LDKCOption_EventZ COption_EventZ_none(void);
8204 export function COption_EventZ_none(): number {
8205 if(!isWasmInitialized) {
8206 throw new Error("initializeWasm() must be awaited first!");
8208 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8209 return nativeResponseValue;
8211 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8213 export function COption_EventZ_free(_res: number): void {
8214 if(!isWasmInitialized) {
8215 throw new Error("initializeWasm() must be awaited first!");
8217 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8218 // debug statements here
8220 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8222 export function COption_EventZ_clone_ptr(arg: number): number {
8223 if(!isWasmInitialized) {
8224 throw new Error("initializeWasm() must be awaited first!");
8226 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8227 return nativeResponseValue;
8229 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8231 export function COption_EventZ_clone(orig: number): number {
8232 if(!isWasmInitialized) {
8233 throw new Error("initializeWasm() must be awaited first!");
8235 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8236 return nativeResponseValue;
8238 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8240 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8241 if(!isWasmInitialized) {
8242 throw new Error("initializeWasm() must be awaited first!");
8244 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8245 return nativeResponseValue;
8247 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8249 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8250 if(!isWasmInitialized) {
8251 throw new Error("initializeWasm() must be awaited first!");
8253 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8254 return nativeResponseValue;
8256 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8258 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8259 if(!isWasmInitialized) {
8260 throw new Error("initializeWasm() must be awaited first!");
8262 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8263 return nativeResponseValue;
8265 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8267 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8268 if(!isWasmInitialized) {
8269 throw new Error("initializeWasm() must be awaited first!");
8271 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8272 // debug statements here
8274 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8276 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8277 if(!isWasmInitialized) {
8278 throw new Error("initializeWasm() must be awaited first!");
8280 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8281 return nativeResponseValue;
8283 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8285 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8286 if(!isWasmInitialized) {
8287 throw new Error("initializeWasm() must be awaited first!");
8289 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8290 return nativeResponseValue;
8292 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
8294 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
8295 if(!isWasmInitialized) {
8296 throw new Error("initializeWasm() must be awaited first!");
8298 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
8299 return nativeResponseValue;
8301 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
8303 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
8304 if(!isWasmInitialized) {
8305 throw new Error("initializeWasm() must be awaited first!");
8307 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
8308 return nativeResponseValue;
8310 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
8312 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
8313 if(!isWasmInitialized) {
8314 throw new Error("initializeWasm() must be awaited first!");
8316 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
8317 return nativeResponseValue;
8319 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
8321 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
8322 if(!isWasmInitialized) {
8323 throw new Error("initializeWasm() must be awaited first!");
8325 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
8326 // debug statements here
8328 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
8330 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
8331 if(!isWasmInitialized) {
8332 throw new Error("initializeWasm() must be awaited first!");
8334 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
8335 return nativeResponseValue;
8337 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
8339 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
8340 if(!isWasmInitialized) {
8341 throw new Error("initializeWasm() must be awaited first!");
8343 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
8344 return nativeResponseValue;
8346 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
8348 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
8349 if(!isWasmInitialized) {
8350 throw new Error("initializeWasm() must be awaited first!");
8352 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
8353 return nativeResponseValue;
8355 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
8357 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
8358 if(!isWasmInitialized) {
8359 throw new Error("initializeWasm() must be awaited first!");
8361 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
8362 return nativeResponseValue;
8364 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
8366 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
8367 if(!isWasmInitialized) {
8368 throw new Error("initializeWasm() must be awaited first!");
8370 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
8371 return nativeResponseValue;
8373 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
8375 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
8376 if(!isWasmInitialized) {
8377 throw new Error("initializeWasm() must be awaited first!");
8379 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
8380 // debug statements here
8382 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
8384 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
8385 if(!isWasmInitialized) {
8386 throw new Error("initializeWasm() must be awaited first!");
8388 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
8389 return nativeResponseValue;
8391 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
8393 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
8394 if(!isWasmInitialized) {
8395 throw new Error("initializeWasm() must be awaited first!");
8397 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
8398 return nativeResponseValue;
8400 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
8402 export function COption_AccessZ_some(o: number): number {
8403 if(!isWasmInitialized) {
8404 throw new Error("initializeWasm() must be awaited first!");
8406 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
8407 return nativeResponseValue;
8409 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
8411 export function COption_AccessZ_none(): number {
8412 if(!isWasmInitialized) {
8413 throw new Error("initializeWasm() must be awaited first!");
8415 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
8416 return nativeResponseValue;
8418 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
8420 export function COption_AccessZ_free(_res: number): void {
8421 if(!isWasmInitialized) {
8422 throw new Error("initializeWasm() must be awaited first!");
8424 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
8425 // debug statements here
8427 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
8429 export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
8430 if(!isWasmInitialized) {
8431 throw new Error("initializeWasm() must be awaited first!");
8433 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_ok(o);
8434 return nativeResponseValue;
8436 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
8438 export function CResult_DirectionalChannelInfoDecodeErrorZ_err(e: number): number {
8439 if(!isWasmInitialized) {
8440 throw new Error("initializeWasm() must be awaited first!");
8442 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_err(e);
8443 return nativeResponseValue;
8445 // bool CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR o);
8447 export function CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
8448 if(!isWasmInitialized) {
8449 throw new Error("initializeWasm() must be awaited first!");
8451 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o);
8452 return nativeResponseValue;
8454 // void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
8456 export function CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: number): void {
8457 if(!isWasmInitialized) {
8458 throw new Error("initializeWasm() must be awaited first!");
8460 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_free(_res);
8461 // debug statements here
8463 // uintptr_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg);
8465 export function CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
8466 if(!isWasmInitialized) {
8467 throw new Error("initializeWasm() must be awaited first!");
8469 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg);
8470 return nativeResponseValue;
8472 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
8474 export function CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: number): number {
8475 if(!isWasmInitialized) {
8476 throw new Error("initializeWasm() must be awaited first!");
8478 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig);
8479 return nativeResponseValue;
8481 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
8483 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
8484 if(!isWasmInitialized) {
8485 throw new Error("initializeWasm() must be awaited first!");
8487 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
8488 return nativeResponseValue;
8490 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
8492 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
8493 if(!isWasmInitialized) {
8494 throw new Error("initializeWasm() must be awaited first!");
8496 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
8497 return nativeResponseValue;
8499 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
8501 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
8502 if(!isWasmInitialized) {
8503 throw new Error("initializeWasm() must be awaited first!");
8505 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
8506 return nativeResponseValue;
8508 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
8510 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
8511 if(!isWasmInitialized) {
8512 throw new Error("initializeWasm() must be awaited first!");
8514 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
8515 // debug statements here
8517 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
8519 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
8520 if(!isWasmInitialized) {
8521 throw new Error("initializeWasm() must be awaited first!");
8523 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
8524 return nativeResponseValue;
8526 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
8528 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
8529 if(!isWasmInitialized) {
8530 throw new Error("initializeWasm() must be awaited first!");
8532 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
8533 return nativeResponseValue;
8535 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
8537 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
8538 if(!isWasmInitialized) {
8539 throw new Error("initializeWasm() must be awaited first!");
8541 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
8542 return nativeResponseValue;
8544 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
8546 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
8547 if(!isWasmInitialized) {
8548 throw new Error("initializeWasm() must be awaited first!");
8550 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
8551 return nativeResponseValue;
8553 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
8555 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
8556 if(!isWasmInitialized) {
8557 throw new Error("initializeWasm() must be awaited first!");
8559 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
8560 return nativeResponseValue;
8562 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
8564 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
8565 if(!isWasmInitialized) {
8566 throw new Error("initializeWasm() must be awaited first!");
8568 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
8569 // debug statements here
8571 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
8573 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
8574 if(!isWasmInitialized) {
8575 throw new Error("initializeWasm() must be awaited first!");
8577 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
8578 return nativeResponseValue;
8580 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
8582 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
8583 if(!isWasmInitialized) {
8584 throw new Error("initializeWasm() must be awaited first!");
8586 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
8587 return nativeResponseValue;
8589 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
8591 export function CVec_NetAddressZ_free(_res: number): void {
8592 if(!isWasmInitialized) {
8593 throw new Error("initializeWasm() must be awaited first!");
8595 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
8596 // debug statements here
8598 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
8600 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
8601 if(!isWasmInitialized) {
8602 throw new Error("initializeWasm() must be awaited first!");
8604 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
8605 return nativeResponseValue;
8607 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
8609 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
8610 if(!isWasmInitialized) {
8611 throw new Error("initializeWasm() must be awaited first!");
8613 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
8614 return nativeResponseValue;
8616 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
8618 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
8619 if(!isWasmInitialized) {
8620 throw new Error("initializeWasm() must be awaited first!");
8622 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
8623 return nativeResponseValue;
8625 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
8627 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
8628 if(!isWasmInitialized) {
8629 throw new Error("initializeWasm() must be awaited first!");
8631 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
8632 // debug statements here
8634 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
8636 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
8637 if(!isWasmInitialized) {
8638 throw new Error("initializeWasm() must be awaited first!");
8640 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
8641 return nativeResponseValue;
8643 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
8645 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
8646 if(!isWasmInitialized) {
8647 throw new Error("initializeWasm() must be awaited first!");
8649 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
8650 return nativeResponseValue;
8652 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8654 export function CVec_u64Z_free(_res: number): void {
8655 if(!isWasmInitialized) {
8656 throw new Error("initializeWasm() must be awaited first!");
8658 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8659 // debug statements here
8661 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
8663 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
8664 if(!isWasmInitialized) {
8665 throw new Error("initializeWasm() must be awaited first!");
8667 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
8668 return nativeResponseValue;
8670 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
8672 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
8673 if(!isWasmInitialized) {
8674 throw new Error("initializeWasm() must be awaited first!");
8676 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
8677 return nativeResponseValue;
8679 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
8681 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
8682 if(!isWasmInitialized) {
8683 throw new Error("initializeWasm() must be awaited first!");
8685 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
8686 return nativeResponseValue;
8688 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
8690 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
8691 if(!isWasmInitialized) {
8692 throw new Error("initializeWasm() must be awaited first!");
8694 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
8695 // debug statements here
8697 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
8699 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
8700 if(!isWasmInitialized) {
8701 throw new Error("initializeWasm() must be awaited first!");
8703 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
8704 return nativeResponseValue;
8706 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
8708 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
8709 if(!isWasmInitialized) {
8710 throw new Error("initializeWasm() must be awaited first!");
8712 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
8713 return nativeResponseValue;
8715 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
8717 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
8718 if(!isWasmInitialized) {
8719 throw new Error("initializeWasm() must be awaited first!");
8721 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
8722 return nativeResponseValue;
8724 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
8726 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
8727 if(!isWasmInitialized) {
8728 throw new Error("initializeWasm() must be awaited first!");
8730 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
8731 return nativeResponseValue;
8733 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
8735 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
8736 if(!isWasmInitialized) {
8737 throw new Error("initializeWasm() must be awaited first!");
8739 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
8740 return nativeResponseValue;
8742 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
8744 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
8745 if(!isWasmInitialized) {
8746 throw new Error("initializeWasm() must be awaited first!");
8748 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
8749 // debug statements here
8751 // uintptr_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
8753 export function CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg: number): number {
8754 if(!isWasmInitialized) {
8755 throw new Error("initializeWasm() must be awaited first!");
8757 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg);
8758 return nativeResponseValue;
8760 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
8762 export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
8763 if(!isWasmInitialized) {
8764 throw new Error("initializeWasm() must be awaited first!");
8766 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone(orig);
8767 return nativeResponseValue;
8769 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
8771 export function COption_CVec_NetAddressZZ_some(o: number): number {
8772 if(!isWasmInitialized) {
8773 throw new Error("initializeWasm() must be awaited first!");
8775 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
8776 return nativeResponseValue;
8778 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
8780 export function COption_CVec_NetAddressZZ_none(): number {
8781 if(!isWasmInitialized) {
8782 throw new Error("initializeWasm() must be awaited first!");
8784 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
8785 return nativeResponseValue;
8787 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
8789 export function COption_CVec_NetAddressZZ_free(_res: number): void {
8790 if(!isWasmInitialized) {
8791 throw new Error("initializeWasm() must be awaited first!");
8793 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
8794 // debug statements here
8796 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
8798 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
8799 if(!isWasmInitialized) {
8800 throw new Error("initializeWasm() must be awaited first!");
8802 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
8803 return nativeResponseValue;
8805 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
8807 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
8808 if(!isWasmInitialized) {
8809 throw new Error("initializeWasm() must be awaited first!");
8811 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
8812 return nativeResponseValue;
8814 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_ok(struct LDKScoringParameters o);
8816 export function CResult_ScoringParametersDecodeErrorZ_ok(o: number): number {
8817 if(!isWasmInitialized) {
8818 throw new Error("initializeWasm() must be awaited first!");
8820 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_ok(o);
8821 return nativeResponseValue;
8823 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8825 export function CResult_ScoringParametersDecodeErrorZ_err(e: number): number {
8826 if(!isWasmInitialized) {
8827 throw new Error("initializeWasm() must be awaited first!");
8829 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_err(e);
8830 return nativeResponseValue;
8832 // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
8834 export function CResult_ScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8835 if(!isWasmInitialized) {
8836 throw new Error("initializeWasm() must be awaited first!");
8838 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_is_ok(o);
8839 return nativeResponseValue;
8841 // void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
8843 export function CResult_ScoringParametersDecodeErrorZ_free(_res: number): void {
8844 if(!isWasmInitialized) {
8845 throw new Error("initializeWasm() must be awaited first!");
8847 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_free(_res);
8848 // debug statements here
8850 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8852 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8853 if(!isWasmInitialized) {
8854 throw new Error("initializeWasm() must be awaited first!");
8856 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8857 return nativeResponseValue;
8859 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8861 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8862 if(!isWasmInitialized) {
8863 throw new Error("initializeWasm() must be awaited first!");
8865 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8866 return nativeResponseValue;
8868 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8870 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8871 if(!isWasmInitialized) {
8872 throw new Error("initializeWasm() must be awaited first!");
8874 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8875 return nativeResponseValue;
8877 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8879 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8880 if(!isWasmInitialized) {
8881 throw new Error("initializeWasm() must be awaited first!");
8883 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8884 // debug statements here
8886 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8888 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8889 if(!isWasmInitialized) {
8890 throw new Error("initializeWasm() must be awaited first!");
8892 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8893 return nativeResponseValue;
8895 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8897 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8898 if(!isWasmInitialized) {
8899 throw new Error("initializeWasm() must be awaited first!");
8901 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8902 return nativeResponseValue;
8904 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8906 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8907 if(!isWasmInitialized) {
8908 throw new Error("initializeWasm() must be awaited first!");
8910 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8911 return nativeResponseValue;
8913 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8915 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8916 if(!isWasmInitialized) {
8917 throw new Error("initializeWasm() must be awaited first!");
8919 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8920 // debug statements here
8922 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8924 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8925 if(!isWasmInitialized) {
8926 throw new Error("initializeWasm() must be awaited first!");
8928 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8929 return nativeResponseValue;
8931 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8933 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8934 if(!isWasmInitialized) {
8935 throw new Error("initializeWasm() must be awaited first!");
8937 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8938 return nativeResponseValue;
8940 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8942 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8943 if(!isWasmInitialized) {
8944 throw new Error("initializeWasm() must be awaited first!");
8946 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8947 return nativeResponseValue;
8949 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8951 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8952 if(!isWasmInitialized) {
8953 throw new Error("initializeWasm() must be awaited first!");
8955 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8956 // debug statements here
8958 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8960 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8961 if(!isWasmInitialized) {
8962 throw new Error("initializeWasm() must be awaited first!");
8964 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8965 return nativeResponseValue;
8967 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8969 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8970 if(!isWasmInitialized) {
8971 throw new Error("initializeWasm() must be awaited first!");
8973 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8974 return nativeResponseValue;
8976 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8978 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8979 if(!isWasmInitialized) {
8980 throw new Error("initializeWasm() must be awaited first!");
8982 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8983 return nativeResponseValue;
8985 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8987 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8988 if(!isWasmInitialized) {
8989 throw new Error("initializeWasm() must be awaited first!");
8991 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8992 // debug statements here
8994 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8996 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8997 if(!isWasmInitialized) {
8998 throw new Error("initializeWasm() must be awaited first!");
9000 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
9001 return nativeResponseValue;
9003 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9005 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
9006 if(!isWasmInitialized) {
9007 throw new Error("initializeWasm() must be awaited first!");
9009 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
9010 return nativeResponseValue;
9012 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
9014 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9015 if(!isWasmInitialized) {
9016 throw new Error("initializeWasm() must be awaited first!");
9018 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9019 return nativeResponseValue;
9021 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9023 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
9024 if(!isWasmInitialized) {
9025 throw new Error("initializeWasm() must be awaited first!");
9027 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9028 // debug statements here
9030 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
9032 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
9033 if(!isWasmInitialized) {
9034 throw new Error("initializeWasm() must be awaited first!");
9036 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
9037 return nativeResponseValue;
9039 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
9041 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
9042 if(!isWasmInitialized) {
9043 throw new Error("initializeWasm() must be awaited first!");
9045 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
9046 return nativeResponseValue;
9048 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
9050 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
9051 if(!isWasmInitialized) {
9052 throw new Error("initializeWasm() must be awaited first!");
9054 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
9055 return nativeResponseValue;
9057 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
9059 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
9060 if(!isWasmInitialized) {
9061 throw new Error("initializeWasm() must be awaited first!");
9063 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
9064 // debug statements here
9066 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
9068 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
9069 if(!isWasmInitialized) {
9070 throw new Error("initializeWasm() must be awaited first!");
9072 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
9073 return nativeResponseValue;
9075 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
9077 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
9078 if(!isWasmInitialized) {
9079 throw new Error("initializeWasm() must be awaited first!");
9081 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
9082 return nativeResponseValue;
9084 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
9086 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
9087 if(!isWasmInitialized) {
9088 throw new Error("initializeWasm() must be awaited first!");
9090 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
9091 // debug statements here
9093 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
9095 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
9096 if(!isWasmInitialized) {
9097 throw new Error("initializeWasm() must be awaited first!");
9099 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
9100 // debug statements here
9102 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
9104 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
9105 if(!isWasmInitialized) {
9106 throw new Error("initializeWasm() must be awaited first!");
9108 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
9109 // debug statements here
9111 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
9113 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
9114 if(!isWasmInitialized) {
9115 throw new Error("initializeWasm() must be awaited first!");
9117 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
9118 // debug statements here
9120 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
9122 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
9123 if(!isWasmInitialized) {
9124 throw new Error("initializeWasm() must be awaited first!");
9126 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
9127 return nativeResponseValue;
9129 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
9131 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
9132 if(!isWasmInitialized) {
9133 throw new Error("initializeWasm() must be awaited first!");
9135 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
9136 return nativeResponseValue;
9138 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
9140 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
9141 if(!isWasmInitialized) {
9142 throw new Error("initializeWasm() must be awaited first!");
9144 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
9145 return nativeResponseValue;
9147 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
9149 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
9150 if(!isWasmInitialized) {
9151 throw new Error("initializeWasm() must be awaited first!");
9153 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
9154 // debug statements here
9156 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
9158 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
9159 if(!isWasmInitialized) {
9160 throw new Error("initializeWasm() must be awaited first!");
9162 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
9163 return nativeResponseValue;
9165 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
9167 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
9168 if(!isWasmInitialized) {
9169 throw new Error("initializeWasm() must be awaited first!");
9171 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
9172 return nativeResponseValue;
9174 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
9176 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
9177 if(!isWasmInitialized) {
9178 throw new Error("initializeWasm() must be awaited first!");
9180 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
9181 return nativeResponseValue;
9183 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
9185 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
9186 if(!isWasmInitialized) {
9187 throw new Error("initializeWasm() must be awaited first!");
9189 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
9190 return nativeResponseValue;
9192 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
9194 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
9195 if(!isWasmInitialized) {
9196 throw new Error("initializeWasm() must be awaited first!");
9198 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
9199 return nativeResponseValue;
9201 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
9203 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
9204 if(!isWasmInitialized) {
9205 throw new Error("initializeWasm() must be awaited first!");
9207 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
9208 // debug statements here
9210 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
9212 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
9213 if(!isWasmInitialized) {
9214 throw new Error("initializeWasm() must be awaited first!");
9216 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
9217 return nativeResponseValue;
9219 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
9221 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
9222 if(!isWasmInitialized) {
9223 throw new Error("initializeWasm() must be awaited first!");
9225 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
9226 return nativeResponseValue;
9228 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
9230 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
9231 if(!isWasmInitialized) {
9232 throw new Error("initializeWasm() must be awaited first!");
9234 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
9235 return nativeResponseValue;
9237 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
9239 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
9240 if(!isWasmInitialized) {
9241 throw new Error("initializeWasm() must be awaited first!");
9243 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
9244 return nativeResponseValue;
9246 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
9248 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
9249 if(!isWasmInitialized) {
9250 throw new Error("initializeWasm() must be awaited first!");
9252 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
9253 return nativeResponseValue;
9255 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
9257 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
9258 if(!isWasmInitialized) {
9259 throw new Error("initializeWasm() must be awaited first!");
9261 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
9262 // debug statements here
9264 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
9266 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
9267 if(!isWasmInitialized) {
9268 throw new Error("initializeWasm() must be awaited first!");
9270 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
9271 return nativeResponseValue;
9273 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
9275 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
9276 if(!isWasmInitialized) {
9277 throw new Error("initializeWasm() must be awaited first!");
9279 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
9280 return nativeResponseValue;
9282 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
9284 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
9285 if(!isWasmInitialized) {
9286 throw new Error("initializeWasm() must be awaited first!");
9288 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
9289 return nativeResponseValue;
9291 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
9293 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
9294 if(!isWasmInitialized) {
9295 throw new Error("initializeWasm() must be awaited first!");
9297 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
9298 return nativeResponseValue;
9300 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
9302 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
9303 if(!isWasmInitialized) {
9304 throw new Error("initializeWasm() must be awaited first!");
9306 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
9307 return nativeResponseValue;
9309 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
9311 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
9312 if(!isWasmInitialized) {
9313 throw new Error("initializeWasm() must be awaited first!");
9315 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
9316 // debug statements here
9318 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
9320 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
9321 if(!isWasmInitialized) {
9322 throw new Error("initializeWasm() must be awaited first!");
9324 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
9325 return nativeResponseValue;
9327 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
9329 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
9330 if(!isWasmInitialized) {
9331 throw new Error("initializeWasm() must be awaited first!");
9333 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
9334 return nativeResponseValue;
9336 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
9338 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
9339 if(!isWasmInitialized) {
9340 throw new Error("initializeWasm() must be awaited first!");
9342 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
9343 return nativeResponseValue;
9345 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
9347 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
9348 if(!isWasmInitialized) {
9349 throw new Error("initializeWasm() must be awaited first!");
9351 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
9352 return nativeResponseValue;
9354 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
9356 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
9357 if(!isWasmInitialized) {
9358 throw new Error("initializeWasm() must be awaited first!");
9360 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
9361 return nativeResponseValue;
9363 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
9365 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
9366 if(!isWasmInitialized) {
9367 throw new Error("initializeWasm() must be awaited first!");
9369 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
9370 // debug statements here
9372 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
9374 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
9375 if(!isWasmInitialized) {
9376 throw new Error("initializeWasm() must be awaited first!");
9378 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
9379 return nativeResponseValue;
9381 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
9383 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
9384 if(!isWasmInitialized) {
9385 throw new Error("initializeWasm() must be awaited first!");
9387 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
9388 return nativeResponseValue;
9390 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
9392 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
9393 if(!isWasmInitialized) {
9394 throw new Error("initializeWasm() must be awaited first!");
9396 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
9397 return nativeResponseValue;
9399 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
9401 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
9402 if(!isWasmInitialized) {
9403 throw new Error("initializeWasm() must be awaited first!");
9405 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
9406 return nativeResponseValue;
9408 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
9410 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
9411 if(!isWasmInitialized) {
9412 throw new Error("initializeWasm() must be awaited first!");
9414 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
9415 return nativeResponseValue;
9417 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
9419 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
9420 if(!isWasmInitialized) {
9421 throw new Error("initializeWasm() must be awaited first!");
9423 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
9424 // debug statements here
9426 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
9428 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
9429 if(!isWasmInitialized) {
9430 throw new Error("initializeWasm() must be awaited first!");
9432 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
9433 return nativeResponseValue;
9435 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
9437 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
9438 if(!isWasmInitialized) {
9439 throw new Error("initializeWasm() must be awaited first!");
9441 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
9442 return nativeResponseValue;
9444 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
9446 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
9447 if(!isWasmInitialized) {
9448 throw new Error("initializeWasm() must be awaited first!");
9450 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
9451 return nativeResponseValue;
9453 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
9455 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
9456 if(!isWasmInitialized) {
9457 throw new Error("initializeWasm() must be awaited first!");
9459 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
9460 return nativeResponseValue;
9462 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
9464 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
9465 if(!isWasmInitialized) {
9466 throw new Error("initializeWasm() must be awaited first!");
9468 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
9469 return nativeResponseValue;
9471 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
9473 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
9474 if(!isWasmInitialized) {
9475 throw new Error("initializeWasm() must be awaited first!");
9477 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
9478 // debug statements here
9480 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
9482 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
9483 if(!isWasmInitialized) {
9484 throw new Error("initializeWasm() must be awaited first!");
9486 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
9487 return nativeResponseValue;
9489 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
9491 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
9492 if(!isWasmInitialized) {
9493 throw new Error("initializeWasm() must be awaited first!");
9495 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
9496 return nativeResponseValue;
9498 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
9500 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
9501 if(!isWasmInitialized) {
9502 throw new Error("initializeWasm() must be awaited first!");
9504 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
9505 return nativeResponseValue;
9507 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
9509 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
9510 if(!isWasmInitialized) {
9511 throw new Error("initializeWasm() must be awaited first!");
9513 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
9514 return nativeResponseValue;
9516 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
9518 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
9519 if(!isWasmInitialized) {
9520 throw new Error("initializeWasm() must be awaited first!");
9522 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
9523 return nativeResponseValue;
9525 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
9527 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
9528 if(!isWasmInitialized) {
9529 throw new Error("initializeWasm() must be awaited first!");
9531 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
9532 // debug statements here
9534 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
9536 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
9537 if(!isWasmInitialized) {
9538 throw new Error("initializeWasm() must be awaited first!");
9540 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
9541 return nativeResponseValue;
9543 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
9545 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
9546 if(!isWasmInitialized) {
9547 throw new Error("initializeWasm() must be awaited first!");
9549 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
9550 return nativeResponseValue;
9552 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
9554 export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
9555 if(!isWasmInitialized) {
9556 throw new Error("initializeWasm() must be awaited first!");
9558 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_ok(o);
9559 return nativeResponseValue;
9561 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
9563 export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
9564 if(!isWasmInitialized) {
9565 throw new Error("initializeWasm() must be awaited first!");
9567 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_err(e);
9568 return nativeResponseValue;
9570 // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
9572 export function CResult_FundingLockedDecodeErrorZ_is_ok(o: number): boolean {
9573 if(!isWasmInitialized) {
9574 throw new Error("initializeWasm() must be awaited first!");
9576 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_is_ok(o);
9577 return nativeResponseValue;
9579 // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
9581 export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
9582 if(!isWasmInitialized) {
9583 throw new Error("initializeWasm() must be awaited first!");
9585 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_free(_res);
9586 // debug statements here
9588 // uintptr_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
9590 export function CResult_FundingLockedDecodeErrorZ_clone_ptr(arg: number): number {
9591 if(!isWasmInitialized) {
9592 throw new Error("initializeWasm() must be awaited first!");
9594 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(arg);
9595 return nativeResponseValue;
9597 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
9599 export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
9600 if(!isWasmInitialized) {
9601 throw new Error("initializeWasm() must be awaited first!");
9603 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone(orig);
9604 return nativeResponseValue;
9606 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
9608 export function CResult_InitDecodeErrorZ_ok(o: number): number {
9609 if(!isWasmInitialized) {
9610 throw new Error("initializeWasm() must be awaited first!");
9612 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
9613 return nativeResponseValue;
9615 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
9617 export function CResult_InitDecodeErrorZ_err(e: number): number {
9618 if(!isWasmInitialized) {
9619 throw new Error("initializeWasm() must be awaited first!");
9621 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
9622 return nativeResponseValue;
9624 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
9626 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
9627 if(!isWasmInitialized) {
9628 throw new Error("initializeWasm() must be awaited first!");
9630 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
9631 return nativeResponseValue;
9633 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
9635 export function CResult_InitDecodeErrorZ_free(_res: number): void {
9636 if(!isWasmInitialized) {
9637 throw new Error("initializeWasm() must be awaited first!");
9639 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
9640 // debug statements here
9642 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
9644 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
9645 if(!isWasmInitialized) {
9646 throw new Error("initializeWasm() must be awaited first!");
9648 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
9649 return nativeResponseValue;
9651 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
9653 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
9654 if(!isWasmInitialized) {
9655 throw new Error("initializeWasm() must be awaited first!");
9657 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
9658 return nativeResponseValue;
9660 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
9662 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
9663 if(!isWasmInitialized) {
9664 throw new Error("initializeWasm() must be awaited first!");
9666 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
9667 return nativeResponseValue;
9669 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
9671 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
9672 if(!isWasmInitialized) {
9673 throw new Error("initializeWasm() must be awaited first!");
9675 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
9676 return nativeResponseValue;
9678 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
9680 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
9681 if(!isWasmInitialized) {
9682 throw new Error("initializeWasm() must be awaited first!");
9684 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
9685 return nativeResponseValue;
9687 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
9689 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
9690 if(!isWasmInitialized) {
9691 throw new Error("initializeWasm() must be awaited first!");
9693 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
9694 // debug statements here
9696 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
9698 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
9699 if(!isWasmInitialized) {
9700 throw new Error("initializeWasm() must be awaited first!");
9702 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
9703 return nativeResponseValue;
9705 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
9707 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
9708 if(!isWasmInitialized) {
9709 throw new Error("initializeWasm() must be awaited first!");
9711 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
9712 return nativeResponseValue;
9714 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
9716 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
9717 if(!isWasmInitialized) {
9718 throw new Error("initializeWasm() must be awaited first!");
9720 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
9721 return nativeResponseValue;
9723 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
9725 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
9726 if(!isWasmInitialized) {
9727 throw new Error("initializeWasm() must be awaited first!");
9729 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
9730 return nativeResponseValue;
9732 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
9734 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
9735 if(!isWasmInitialized) {
9736 throw new Error("initializeWasm() must be awaited first!");
9738 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
9739 return nativeResponseValue;
9741 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
9743 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
9744 if(!isWasmInitialized) {
9745 throw new Error("initializeWasm() must be awaited first!");
9747 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
9748 // debug statements here
9750 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
9752 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
9753 if(!isWasmInitialized) {
9754 throw new Error("initializeWasm() must be awaited first!");
9756 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
9757 return nativeResponseValue;
9759 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
9761 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
9762 if(!isWasmInitialized) {
9763 throw new Error("initializeWasm() must be awaited first!");
9765 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
9766 return nativeResponseValue;
9768 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
9770 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
9771 if(!isWasmInitialized) {
9772 throw new Error("initializeWasm() must be awaited first!");
9774 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
9775 return nativeResponseValue;
9777 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
9779 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
9780 if(!isWasmInitialized) {
9781 throw new Error("initializeWasm() must be awaited first!");
9783 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
9784 return nativeResponseValue;
9786 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
9788 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
9789 if(!isWasmInitialized) {
9790 throw new Error("initializeWasm() must be awaited first!");
9792 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
9793 return nativeResponseValue;
9795 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
9797 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
9798 if(!isWasmInitialized) {
9799 throw new Error("initializeWasm() must be awaited first!");
9801 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
9802 // debug statements here
9804 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
9806 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
9807 if(!isWasmInitialized) {
9808 throw new Error("initializeWasm() must be awaited first!");
9810 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
9811 return nativeResponseValue;
9813 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
9815 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
9816 if(!isWasmInitialized) {
9817 throw new Error("initializeWasm() must be awaited first!");
9819 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
9820 return nativeResponseValue;
9822 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
9824 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
9825 if(!isWasmInitialized) {
9826 throw new Error("initializeWasm() must be awaited first!");
9828 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
9829 return nativeResponseValue;
9831 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
9833 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
9834 if(!isWasmInitialized) {
9835 throw new Error("initializeWasm() must be awaited first!");
9837 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
9838 return nativeResponseValue;
9840 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
9842 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
9843 if(!isWasmInitialized) {
9844 throw new Error("initializeWasm() must be awaited first!");
9846 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
9847 return nativeResponseValue;
9849 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
9851 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
9852 if(!isWasmInitialized) {
9853 throw new Error("initializeWasm() must be awaited first!");
9855 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
9856 // debug statements here
9858 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
9860 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
9861 if(!isWasmInitialized) {
9862 throw new Error("initializeWasm() must be awaited first!");
9864 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
9865 return nativeResponseValue;
9867 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
9869 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
9870 if(!isWasmInitialized) {
9871 throw new Error("initializeWasm() must be awaited first!");
9873 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
9874 return nativeResponseValue;
9876 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
9878 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
9879 if(!isWasmInitialized) {
9880 throw new Error("initializeWasm() must be awaited first!");
9882 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
9883 return nativeResponseValue;
9885 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
9887 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
9888 if(!isWasmInitialized) {
9889 throw new Error("initializeWasm() must be awaited first!");
9891 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
9892 return nativeResponseValue;
9894 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
9896 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
9897 if(!isWasmInitialized) {
9898 throw new Error("initializeWasm() must be awaited first!");
9900 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
9901 return nativeResponseValue;
9903 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
9905 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
9906 if(!isWasmInitialized) {
9907 throw new Error("initializeWasm() must be awaited first!");
9909 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
9910 // debug statements here
9912 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
9914 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
9915 if(!isWasmInitialized) {
9916 throw new Error("initializeWasm() must be awaited first!");
9918 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
9919 return nativeResponseValue;
9921 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
9923 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
9924 if(!isWasmInitialized) {
9925 throw new Error("initializeWasm() must be awaited first!");
9927 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
9928 return nativeResponseValue;
9930 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
9932 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
9933 if(!isWasmInitialized) {
9934 throw new Error("initializeWasm() must be awaited first!");
9936 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
9937 return nativeResponseValue;
9939 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
9941 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
9942 if(!isWasmInitialized) {
9943 throw new Error("initializeWasm() must be awaited first!");
9945 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
9946 return nativeResponseValue;
9948 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
9950 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
9951 if(!isWasmInitialized) {
9952 throw new Error("initializeWasm() must be awaited first!");
9954 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
9955 return nativeResponseValue;
9957 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
9959 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
9960 if(!isWasmInitialized) {
9961 throw new Error("initializeWasm() must be awaited first!");
9963 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
9964 // debug statements here
9966 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
9968 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
9969 if(!isWasmInitialized) {
9970 throw new Error("initializeWasm() must be awaited first!");
9972 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
9973 return nativeResponseValue;
9975 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
9977 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
9978 if(!isWasmInitialized) {
9979 throw new Error("initializeWasm() must be awaited first!");
9981 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
9982 return nativeResponseValue;
9984 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
9986 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
9987 if(!isWasmInitialized) {
9988 throw new Error("initializeWasm() must be awaited first!");
9990 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
9991 return nativeResponseValue;
9993 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
9995 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
9996 if(!isWasmInitialized) {
9997 throw new Error("initializeWasm() must be awaited first!");
9999 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
10000 return nativeResponseValue;
10002 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
10004 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
10005 if(!isWasmInitialized) {
10006 throw new Error("initializeWasm() must be awaited first!");
10008 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
10009 return nativeResponseValue;
10011 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
10013 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
10014 if(!isWasmInitialized) {
10015 throw new Error("initializeWasm() must be awaited first!");
10017 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
10018 // debug statements here
10020 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
10022 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
10023 if(!isWasmInitialized) {
10024 throw new Error("initializeWasm() must be awaited first!");
10026 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
10027 return nativeResponseValue;
10029 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
10031 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
10032 if(!isWasmInitialized) {
10033 throw new Error("initializeWasm() must be awaited first!");
10035 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
10036 return nativeResponseValue;
10038 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
10040 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
10041 if(!isWasmInitialized) {
10042 throw new Error("initializeWasm() must be awaited first!");
10044 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
10045 return nativeResponseValue;
10047 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
10049 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
10050 if(!isWasmInitialized) {
10051 throw new Error("initializeWasm() must be awaited first!");
10053 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
10054 return nativeResponseValue;
10056 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
10058 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
10059 if(!isWasmInitialized) {
10060 throw new Error("initializeWasm() must be awaited first!");
10062 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
10063 return nativeResponseValue;
10065 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
10067 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
10068 if(!isWasmInitialized) {
10069 throw new Error("initializeWasm() must be awaited first!");
10071 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
10072 // debug statements here
10074 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
10076 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
10077 if(!isWasmInitialized) {
10078 throw new Error("initializeWasm() must be awaited first!");
10080 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
10081 return nativeResponseValue;
10083 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
10085 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
10086 if(!isWasmInitialized) {
10087 throw new Error("initializeWasm() must be awaited first!");
10089 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
10090 return nativeResponseValue;
10092 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
10094 export function CResult_PingDecodeErrorZ_ok(o: number): number {
10095 if(!isWasmInitialized) {
10096 throw new Error("initializeWasm() must be awaited first!");
10098 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
10099 return nativeResponseValue;
10101 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
10103 export function CResult_PingDecodeErrorZ_err(e: number): number {
10104 if(!isWasmInitialized) {
10105 throw new Error("initializeWasm() must be awaited first!");
10107 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
10108 return nativeResponseValue;
10110 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
10112 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
10113 if(!isWasmInitialized) {
10114 throw new Error("initializeWasm() must be awaited first!");
10116 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
10117 return nativeResponseValue;
10119 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
10121 export function CResult_PingDecodeErrorZ_free(_res: number): void {
10122 if(!isWasmInitialized) {
10123 throw new Error("initializeWasm() must be awaited first!");
10125 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
10126 // debug statements here
10128 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
10130 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
10131 if(!isWasmInitialized) {
10132 throw new Error("initializeWasm() must be awaited first!");
10134 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
10135 return nativeResponseValue;
10137 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
10139 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
10140 if(!isWasmInitialized) {
10141 throw new Error("initializeWasm() must be awaited first!");
10143 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
10144 return nativeResponseValue;
10146 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
10148 export function CResult_PongDecodeErrorZ_ok(o: number): number {
10149 if(!isWasmInitialized) {
10150 throw new Error("initializeWasm() must be awaited first!");
10152 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
10153 return nativeResponseValue;
10155 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
10157 export function CResult_PongDecodeErrorZ_err(e: number): number {
10158 if(!isWasmInitialized) {
10159 throw new Error("initializeWasm() must be awaited first!");
10161 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
10162 return nativeResponseValue;
10164 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
10166 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
10167 if(!isWasmInitialized) {
10168 throw new Error("initializeWasm() must be awaited first!");
10170 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
10171 return nativeResponseValue;
10173 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
10175 export function CResult_PongDecodeErrorZ_free(_res: number): void {
10176 if(!isWasmInitialized) {
10177 throw new Error("initializeWasm() must be awaited first!");
10179 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
10180 // debug statements here
10182 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
10184 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
10185 if(!isWasmInitialized) {
10186 throw new Error("initializeWasm() must be awaited first!");
10188 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
10189 return nativeResponseValue;
10191 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
10193 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
10194 if(!isWasmInitialized) {
10195 throw new Error("initializeWasm() must be awaited first!");
10197 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
10198 return nativeResponseValue;
10200 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
10202 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
10203 if(!isWasmInitialized) {
10204 throw new Error("initializeWasm() must be awaited first!");
10206 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
10207 return nativeResponseValue;
10209 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10211 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
10212 if(!isWasmInitialized) {
10213 throw new Error("initializeWasm() must be awaited first!");
10215 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
10216 return nativeResponseValue;
10218 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
10220 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10221 if(!isWasmInitialized) {
10222 throw new Error("initializeWasm() must be awaited first!");
10224 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
10225 return nativeResponseValue;
10227 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
10229 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
10230 if(!isWasmInitialized) {
10231 throw new Error("initializeWasm() must be awaited first!");
10233 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
10234 // debug statements here
10236 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10238 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10239 if(!isWasmInitialized) {
10240 throw new Error("initializeWasm() must be awaited first!");
10242 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
10243 return nativeResponseValue;
10245 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10247 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
10248 if(!isWasmInitialized) {
10249 throw new Error("initializeWasm() must be awaited first!");
10251 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
10252 return nativeResponseValue;
10254 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
10256 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
10257 if(!isWasmInitialized) {
10258 throw new Error("initializeWasm() must be awaited first!");
10260 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
10261 return nativeResponseValue;
10263 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10265 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
10266 if(!isWasmInitialized) {
10267 throw new Error("initializeWasm() must be awaited first!");
10269 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
10270 return nativeResponseValue;
10272 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
10274 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10275 if(!isWasmInitialized) {
10276 throw new Error("initializeWasm() must be awaited first!");
10278 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
10279 return nativeResponseValue;
10281 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
10283 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
10284 if(!isWasmInitialized) {
10285 throw new Error("initializeWasm() must be awaited first!");
10287 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
10288 // debug statements here
10290 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10292 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10293 if(!isWasmInitialized) {
10294 throw new Error("initializeWasm() must be awaited first!");
10296 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
10297 return nativeResponseValue;
10299 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10301 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
10302 if(!isWasmInitialized) {
10303 throw new Error("initializeWasm() must be awaited first!");
10305 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
10306 return nativeResponseValue;
10308 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
10310 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
10311 if(!isWasmInitialized) {
10312 throw new Error("initializeWasm() must be awaited first!");
10314 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
10315 return nativeResponseValue;
10317 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
10319 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
10320 if(!isWasmInitialized) {
10321 throw new Error("initializeWasm() must be awaited first!");
10323 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
10324 return nativeResponseValue;
10326 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
10328 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
10329 if(!isWasmInitialized) {
10330 throw new Error("initializeWasm() must be awaited first!");
10332 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
10333 return nativeResponseValue;
10335 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
10337 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
10338 if(!isWasmInitialized) {
10339 throw new Error("initializeWasm() must be awaited first!");
10341 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
10342 // debug statements here
10344 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
10346 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
10347 if(!isWasmInitialized) {
10348 throw new Error("initializeWasm() must be awaited first!");
10350 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
10351 return nativeResponseValue;
10353 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
10355 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
10356 if(!isWasmInitialized) {
10357 throw new Error("initializeWasm() must be awaited first!");
10359 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
10360 return nativeResponseValue;
10362 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
10364 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
10365 if(!isWasmInitialized) {
10366 throw new Error("initializeWasm() must be awaited first!");
10368 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
10369 return nativeResponseValue;
10371 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
10373 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
10374 if(!isWasmInitialized) {
10375 throw new Error("initializeWasm() must be awaited first!");
10377 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
10378 return nativeResponseValue;
10380 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
10382 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
10383 if(!isWasmInitialized) {
10384 throw new Error("initializeWasm() must be awaited first!");
10386 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
10387 return nativeResponseValue;
10389 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
10391 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
10392 if(!isWasmInitialized) {
10393 throw new Error("initializeWasm() must be awaited first!");
10395 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
10396 // debug statements here
10398 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
10400 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
10401 if(!isWasmInitialized) {
10402 throw new Error("initializeWasm() must be awaited first!");
10404 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
10405 return nativeResponseValue;
10407 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
10409 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
10410 if(!isWasmInitialized) {
10411 throw new Error("initializeWasm() must be awaited first!");
10413 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
10414 return nativeResponseValue;
10416 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
10418 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
10419 if(!isWasmInitialized) {
10420 throw new Error("initializeWasm() must be awaited first!");
10422 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
10423 return nativeResponseValue;
10425 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
10427 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
10428 if(!isWasmInitialized) {
10429 throw new Error("initializeWasm() must be awaited first!");
10431 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
10432 return nativeResponseValue;
10434 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
10436 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
10437 if(!isWasmInitialized) {
10438 throw new Error("initializeWasm() must be awaited first!");
10440 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
10441 return nativeResponseValue;
10443 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
10445 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
10446 if(!isWasmInitialized) {
10447 throw new Error("initializeWasm() must be awaited first!");
10449 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
10450 // debug statements here
10452 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
10454 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
10455 if(!isWasmInitialized) {
10456 throw new Error("initializeWasm() must be awaited first!");
10458 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
10459 return nativeResponseValue;
10461 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
10463 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
10464 if(!isWasmInitialized) {
10465 throw new Error("initializeWasm() must be awaited first!");
10467 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
10468 return nativeResponseValue;
10470 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
10472 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
10473 if(!isWasmInitialized) {
10474 throw new Error("initializeWasm() must be awaited first!");
10476 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
10477 return nativeResponseValue;
10479 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10481 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
10482 if(!isWasmInitialized) {
10483 throw new Error("initializeWasm() must be awaited first!");
10485 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
10486 return nativeResponseValue;
10488 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
10490 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10491 if(!isWasmInitialized) {
10492 throw new Error("initializeWasm() must be awaited first!");
10494 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
10495 return nativeResponseValue;
10497 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
10499 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
10500 if(!isWasmInitialized) {
10501 throw new Error("initializeWasm() must be awaited first!");
10503 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
10504 // debug statements here
10506 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10508 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10509 if(!isWasmInitialized) {
10510 throw new Error("initializeWasm() must be awaited first!");
10512 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
10513 return nativeResponseValue;
10515 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10517 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
10518 if(!isWasmInitialized) {
10519 throw new Error("initializeWasm() must be awaited first!");
10521 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
10522 return nativeResponseValue;
10524 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
10526 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
10527 if(!isWasmInitialized) {
10528 throw new Error("initializeWasm() must be awaited first!");
10530 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
10531 return nativeResponseValue;
10533 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10535 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
10536 if(!isWasmInitialized) {
10537 throw new Error("initializeWasm() must be awaited first!");
10539 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
10540 return nativeResponseValue;
10542 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
10544 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10545 if(!isWasmInitialized) {
10546 throw new Error("initializeWasm() must be awaited first!");
10548 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
10549 return nativeResponseValue;
10551 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
10553 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
10554 if(!isWasmInitialized) {
10555 throw new Error("initializeWasm() must be awaited first!");
10557 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
10558 // debug statements here
10560 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10562 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10563 if(!isWasmInitialized) {
10564 throw new Error("initializeWasm() must be awaited first!");
10566 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
10567 return nativeResponseValue;
10569 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10571 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
10572 if(!isWasmInitialized) {
10573 throw new Error("initializeWasm() must be awaited first!");
10575 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
10576 return nativeResponseValue;
10578 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
10580 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
10581 if(!isWasmInitialized) {
10582 throw new Error("initializeWasm() must be awaited first!");
10584 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
10585 return nativeResponseValue;
10587 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
10589 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
10590 if(!isWasmInitialized) {
10591 throw new Error("initializeWasm() must be awaited first!");
10593 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
10594 return nativeResponseValue;
10596 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
10598 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
10599 if(!isWasmInitialized) {
10600 throw new Error("initializeWasm() must be awaited first!");
10602 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
10603 return nativeResponseValue;
10605 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
10607 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
10608 if(!isWasmInitialized) {
10609 throw new Error("initializeWasm() must be awaited first!");
10611 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
10612 // debug statements here
10614 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
10616 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
10617 if(!isWasmInitialized) {
10618 throw new Error("initializeWasm() must be awaited first!");
10620 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
10621 return nativeResponseValue;
10623 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
10625 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
10626 if(!isWasmInitialized) {
10627 throw new Error("initializeWasm() must be awaited first!");
10629 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
10630 return nativeResponseValue;
10632 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
10634 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
10635 if(!isWasmInitialized) {
10636 throw new Error("initializeWasm() must be awaited first!");
10638 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
10639 return nativeResponseValue;
10641 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
10643 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
10644 if(!isWasmInitialized) {
10645 throw new Error("initializeWasm() must be awaited first!");
10647 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
10648 return nativeResponseValue;
10650 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
10652 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
10653 if(!isWasmInitialized) {
10654 throw new Error("initializeWasm() must be awaited first!");
10656 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
10657 return nativeResponseValue;
10659 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
10661 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
10662 if(!isWasmInitialized) {
10663 throw new Error("initializeWasm() must be awaited first!");
10665 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
10666 // debug statements here
10668 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
10670 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
10671 if(!isWasmInitialized) {
10672 throw new Error("initializeWasm() must be awaited first!");
10674 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
10675 return nativeResponseValue;
10677 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
10679 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
10680 if(!isWasmInitialized) {
10681 throw new Error("initializeWasm() must be awaited first!");
10683 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
10684 return nativeResponseValue;
10686 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
10688 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
10689 if(!isWasmInitialized) {
10690 throw new Error("initializeWasm() must be awaited first!");
10692 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
10693 return nativeResponseValue;
10695 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
10697 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
10698 if(!isWasmInitialized) {
10699 throw new Error("initializeWasm() must be awaited first!");
10701 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
10702 return nativeResponseValue;
10704 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
10706 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
10707 if(!isWasmInitialized) {
10708 throw new Error("initializeWasm() must be awaited first!");
10710 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
10711 return nativeResponseValue;
10713 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
10715 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
10716 if(!isWasmInitialized) {
10717 throw new Error("initializeWasm() must be awaited first!");
10719 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
10720 // debug statements here
10722 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
10724 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
10725 if(!isWasmInitialized) {
10726 throw new Error("initializeWasm() must be awaited first!");
10728 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
10729 return nativeResponseValue;
10731 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
10733 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
10734 if(!isWasmInitialized) {
10735 throw new Error("initializeWasm() must be awaited first!");
10737 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
10738 return nativeResponseValue;
10740 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
10742 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
10743 if(!isWasmInitialized) {
10744 throw new Error("initializeWasm() must be awaited first!");
10746 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
10747 return nativeResponseValue;
10749 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
10751 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
10752 if(!isWasmInitialized) {
10753 throw new Error("initializeWasm() must be awaited first!");
10755 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
10756 return nativeResponseValue;
10758 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
10760 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
10761 if(!isWasmInitialized) {
10762 throw new Error("initializeWasm() must be awaited first!");
10764 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
10765 return nativeResponseValue;
10767 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
10769 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
10770 if(!isWasmInitialized) {
10771 throw new Error("initializeWasm() must be awaited first!");
10773 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
10774 // debug statements here
10776 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
10778 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
10779 if(!isWasmInitialized) {
10780 throw new Error("initializeWasm() must be awaited first!");
10782 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
10783 return nativeResponseValue;
10785 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
10787 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
10788 if(!isWasmInitialized) {
10789 throw new Error("initializeWasm() must be awaited first!");
10791 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
10792 return nativeResponseValue;
10794 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
10796 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
10797 if(!isWasmInitialized) {
10798 throw new Error("initializeWasm() must be awaited first!");
10800 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
10801 return nativeResponseValue;
10803 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
10805 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
10806 if(!isWasmInitialized) {
10807 throw new Error("initializeWasm() must be awaited first!");
10809 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
10810 return nativeResponseValue;
10812 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
10814 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
10815 if(!isWasmInitialized) {
10816 throw new Error("initializeWasm() must be awaited first!");
10818 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
10819 return nativeResponseValue;
10821 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
10823 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
10824 if(!isWasmInitialized) {
10825 throw new Error("initializeWasm() must be awaited first!");
10827 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
10828 // debug statements here
10830 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
10832 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
10833 if(!isWasmInitialized) {
10834 throw new Error("initializeWasm() must be awaited first!");
10836 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
10837 return nativeResponseValue;
10839 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
10841 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
10842 if(!isWasmInitialized) {
10843 throw new Error("initializeWasm() must be awaited first!");
10845 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
10846 return nativeResponseValue;
10848 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10850 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10851 if(!isWasmInitialized) {
10852 throw new Error("initializeWasm() must be awaited first!");
10854 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10855 return nativeResponseValue;
10857 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10859 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10860 if(!isWasmInitialized) {
10861 throw new Error("initializeWasm() must be awaited first!");
10863 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10864 return nativeResponseValue;
10866 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10868 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10869 if(!isWasmInitialized) {
10870 throw new Error("initializeWasm() must be awaited first!");
10872 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10873 return nativeResponseValue;
10875 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10877 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10878 if(!isWasmInitialized) {
10879 throw new Error("initializeWasm() must be awaited first!");
10881 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10882 // debug statements here
10884 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10886 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10887 if(!isWasmInitialized) {
10888 throw new Error("initializeWasm() must be awaited first!");
10890 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10891 return nativeResponseValue;
10893 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10895 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10896 if(!isWasmInitialized) {
10897 throw new Error("initializeWasm() must be awaited first!");
10899 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10900 return nativeResponseValue;
10902 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10904 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10905 if(!isWasmInitialized) {
10906 throw new Error("initializeWasm() must be awaited first!");
10908 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10909 return nativeResponseValue;
10911 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10913 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10914 if(!isWasmInitialized) {
10915 throw new Error("initializeWasm() must be awaited first!");
10917 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
10918 return nativeResponseValue;
10920 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10922 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10923 if(!isWasmInitialized) {
10924 throw new Error("initializeWasm() must be awaited first!");
10926 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10927 return nativeResponseValue;
10929 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
10931 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10932 if(!isWasmInitialized) {
10933 throw new Error("initializeWasm() must be awaited first!");
10935 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
10936 // debug statements here
10938 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10940 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10941 if(!isWasmInitialized) {
10942 throw new Error("initializeWasm() must be awaited first!");
10944 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10945 return nativeResponseValue;
10947 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10949 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10950 if(!isWasmInitialized) {
10951 throw new Error("initializeWasm() must be awaited first!");
10953 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10954 return nativeResponseValue;
10956 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
10958 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
10959 if(!isWasmInitialized) {
10960 throw new Error("initializeWasm() must be awaited first!");
10962 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
10963 return nativeResponseValue;
10965 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10967 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
10968 if(!isWasmInitialized) {
10969 throw new Error("initializeWasm() must be awaited first!");
10971 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
10972 return nativeResponseValue;
10974 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10976 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10977 if(!isWasmInitialized) {
10978 throw new Error("initializeWasm() must be awaited first!");
10980 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
10981 return nativeResponseValue;
10983 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
10985 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
10986 if(!isWasmInitialized) {
10987 throw new Error("initializeWasm() must be awaited first!");
10989 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10990 // debug statements here
10992 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10994 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10995 if(!isWasmInitialized) {
10996 throw new Error("initializeWasm() must be awaited first!");
10998 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10999 return nativeResponseValue;
11001 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
11003 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
11004 if(!isWasmInitialized) {
11005 throw new Error("initializeWasm() must be awaited first!");
11007 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
11008 return nativeResponseValue;
11010 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
11012 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
11013 if(!isWasmInitialized) {
11014 throw new Error("initializeWasm() must be awaited first!");
11016 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
11017 return nativeResponseValue;
11019 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
11021 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
11022 if(!isWasmInitialized) {
11023 throw new Error("initializeWasm() must be awaited first!");
11025 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
11026 return nativeResponseValue;
11028 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
11030 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
11031 if(!isWasmInitialized) {
11032 throw new Error("initializeWasm() must be awaited first!");
11034 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
11035 return nativeResponseValue;
11037 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
11039 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
11040 if(!isWasmInitialized) {
11041 throw new Error("initializeWasm() must be awaited first!");
11043 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
11044 // debug statements here
11046 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
11048 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
11049 if(!isWasmInitialized) {
11050 throw new Error("initializeWasm() must be awaited first!");
11052 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
11053 return nativeResponseValue;
11055 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
11057 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
11058 if(!isWasmInitialized) {
11059 throw new Error("initializeWasm() must be awaited first!");
11061 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
11062 return nativeResponseValue;
11064 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
11066 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
11067 if(!isWasmInitialized) {
11068 throw new Error("initializeWasm() must be awaited first!");
11070 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
11071 return nativeResponseValue;
11073 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
11075 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
11076 if(!isWasmInitialized) {
11077 throw new Error("initializeWasm() must be awaited first!");
11079 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
11080 // debug statements here
11082 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
11084 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
11085 if(!isWasmInitialized) {
11086 throw new Error("initializeWasm() must be awaited first!");
11088 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
11089 return nativeResponseValue;
11091 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
11093 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
11094 if(!isWasmInitialized) {
11095 throw new Error("initializeWasm() must be awaited first!");
11097 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
11098 return nativeResponseValue;
11100 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
11102 export function CResult_SignatureNoneZ_ok(o: number): number {
11103 if(!isWasmInitialized) {
11104 throw new Error("initializeWasm() must be awaited first!");
11106 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
11107 return nativeResponseValue;
11109 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
11111 export function CResult_SignatureNoneZ_err(): number {
11112 if(!isWasmInitialized) {
11113 throw new Error("initializeWasm() must be awaited first!");
11115 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
11116 return nativeResponseValue;
11118 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
11120 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
11121 if(!isWasmInitialized) {
11122 throw new Error("initializeWasm() must be awaited first!");
11124 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
11125 return nativeResponseValue;
11127 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
11129 export function CResult_SignatureNoneZ_free(_res: number): void {
11130 if(!isWasmInitialized) {
11131 throw new Error("initializeWasm() must be awaited first!");
11133 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
11134 // debug statements here
11136 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
11138 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
11139 if(!isWasmInitialized) {
11140 throw new Error("initializeWasm() must be awaited first!");
11142 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
11143 return nativeResponseValue;
11145 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
11147 export function CResult_SignatureNoneZ_clone(orig: number): number {
11148 if(!isWasmInitialized) {
11149 throw new Error("initializeWasm() must be awaited first!");
11151 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
11152 return nativeResponseValue;
11154 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
11156 export function CResult_SignDecodeErrorZ_ok(o: number): number {
11157 if(!isWasmInitialized) {
11158 throw new Error("initializeWasm() must be awaited first!");
11160 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
11161 return nativeResponseValue;
11163 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
11165 export function CResult_SignDecodeErrorZ_err(e: number): number {
11166 if(!isWasmInitialized) {
11167 throw new Error("initializeWasm() must be awaited first!");
11169 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
11170 return nativeResponseValue;
11172 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
11174 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
11175 if(!isWasmInitialized) {
11176 throw new Error("initializeWasm() must be awaited first!");
11178 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
11179 return nativeResponseValue;
11181 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
11183 export function CResult_SignDecodeErrorZ_free(_res: number): void {
11184 if(!isWasmInitialized) {
11185 throw new Error("initializeWasm() must be awaited first!");
11187 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
11188 // debug statements here
11190 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
11192 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
11193 if(!isWasmInitialized) {
11194 throw new Error("initializeWasm() must be awaited first!");
11196 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
11197 return nativeResponseValue;
11199 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
11201 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
11202 if(!isWasmInitialized) {
11203 throw new Error("initializeWasm() must be awaited first!");
11205 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
11206 return nativeResponseValue;
11208 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
11210 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
11211 if(!isWasmInitialized) {
11212 throw new Error("initializeWasm() must be awaited first!");
11214 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
11215 return nativeResponseValue;
11217 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
11219 export function CResult_RecoverableSignatureNoneZ_err(): number {
11220 if(!isWasmInitialized) {
11221 throw new Error("initializeWasm() must be awaited first!");
11223 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
11224 return nativeResponseValue;
11226 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
11228 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
11229 if(!isWasmInitialized) {
11230 throw new Error("initializeWasm() must be awaited first!");
11232 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
11233 return nativeResponseValue;
11235 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
11237 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
11238 if(!isWasmInitialized) {
11239 throw new Error("initializeWasm() must be awaited first!");
11241 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
11242 // debug statements here
11244 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
11246 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
11247 if(!isWasmInitialized) {
11248 throw new Error("initializeWasm() must be awaited first!");
11250 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
11251 return nativeResponseValue;
11253 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
11255 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
11256 if(!isWasmInitialized) {
11257 throw new Error("initializeWasm() must be awaited first!");
11259 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
11260 return nativeResponseValue;
11262 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
11264 export function CVec_CVec_u8ZZ_free(_res: number): void {
11265 if(!isWasmInitialized) {
11266 throw new Error("initializeWasm() must be awaited first!");
11268 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
11269 // debug statements here
11271 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
11273 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
11274 if(!isWasmInitialized) {
11275 throw new Error("initializeWasm() must be awaited first!");
11277 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
11278 return nativeResponseValue;
11280 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
11282 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
11283 if(!isWasmInitialized) {
11284 throw new Error("initializeWasm() must be awaited first!");
11286 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
11287 return nativeResponseValue;
11289 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
11291 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
11292 if(!isWasmInitialized) {
11293 throw new Error("initializeWasm() must be awaited first!");
11295 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
11296 return nativeResponseValue;
11298 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
11300 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
11301 if(!isWasmInitialized) {
11302 throw new Error("initializeWasm() must be awaited first!");
11304 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
11305 // debug statements here
11307 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
11309 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
11310 if(!isWasmInitialized) {
11311 throw new Error("initializeWasm() must be awaited first!");
11313 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
11314 return nativeResponseValue;
11316 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
11318 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
11319 if(!isWasmInitialized) {
11320 throw new Error("initializeWasm() must be awaited first!");
11322 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
11323 return nativeResponseValue;
11325 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
11327 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
11328 if(!isWasmInitialized) {
11329 throw new Error("initializeWasm() must be awaited first!");
11331 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
11332 return nativeResponseValue;
11334 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
11336 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
11337 if(!isWasmInitialized) {
11338 throw new Error("initializeWasm() must be awaited first!");
11340 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
11341 return nativeResponseValue;
11343 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
11345 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
11346 if(!isWasmInitialized) {
11347 throw new Error("initializeWasm() must be awaited first!");
11349 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
11350 return nativeResponseValue;
11352 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
11354 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
11355 if(!isWasmInitialized) {
11356 throw new Error("initializeWasm() must be awaited first!");
11358 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
11359 // debug statements here
11361 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
11363 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
11364 if(!isWasmInitialized) {
11365 throw new Error("initializeWasm() must be awaited first!");
11367 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
11368 return nativeResponseValue;
11370 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
11372 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
11373 if(!isWasmInitialized) {
11374 throw new Error("initializeWasm() must be awaited first!");
11376 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
11377 return nativeResponseValue;
11379 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11381 export function CVec_TxOutZ_free(_res: number): void {
11382 if(!isWasmInitialized) {
11383 throw new Error("initializeWasm() must be awaited first!");
11385 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11386 // debug statements here
11388 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
11390 export function CResult_TransactionNoneZ_ok(o: number): number {
11391 if(!isWasmInitialized) {
11392 throw new Error("initializeWasm() must be awaited first!");
11394 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
11395 return nativeResponseValue;
11397 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
11399 export function CResult_TransactionNoneZ_err(): number {
11400 if(!isWasmInitialized) {
11401 throw new Error("initializeWasm() must be awaited first!");
11403 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
11404 return nativeResponseValue;
11406 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
11408 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
11409 if(!isWasmInitialized) {
11410 throw new Error("initializeWasm() must be awaited first!");
11412 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
11413 return nativeResponseValue;
11415 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
11417 export function CResult_TransactionNoneZ_free(_res: number): void {
11418 if(!isWasmInitialized) {
11419 throw new Error("initializeWasm() must be awaited first!");
11421 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
11422 // debug statements here
11424 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
11426 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
11427 if(!isWasmInitialized) {
11428 throw new Error("initializeWasm() must be awaited first!");
11430 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
11431 return nativeResponseValue;
11433 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
11435 export function CResult_TransactionNoneZ_clone(orig: number): number {
11436 if(!isWasmInitialized) {
11437 throw new Error("initializeWasm() must be awaited first!");
11439 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
11440 return nativeResponseValue;
11442 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
11444 export function COption_FilterZ_some(o: number): number {
11445 if(!isWasmInitialized) {
11446 throw new Error("initializeWasm() must be awaited first!");
11448 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
11449 return nativeResponseValue;
11451 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
11453 export function COption_FilterZ_none(): number {
11454 if(!isWasmInitialized) {
11455 throw new Error("initializeWasm() must be awaited first!");
11457 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
11458 return nativeResponseValue;
11460 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
11462 export function COption_FilterZ_free(_res: number): void {
11463 if(!isWasmInitialized) {
11464 throw new Error("initializeWasm() must be awaited first!");
11466 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
11467 // debug statements here
11469 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
11471 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
11472 if(!isWasmInitialized) {
11473 throw new Error("initializeWasm() must be awaited first!");
11475 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
11476 return nativeResponseValue;
11478 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
11480 export function CResult_LockedChannelMonitorNoneZ_err(): number {
11481 if(!isWasmInitialized) {
11482 throw new Error("initializeWasm() must be awaited first!");
11484 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
11485 return nativeResponseValue;
11487 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
11489 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
11490 if(!isWasmInitialized) {
11491 throw new Error("initializeWasm() must be awaited first!");
11493 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
11494 return nativeResponseValue;
11496 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
11498 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
11499 if(!isWasmInitialized) {
11500 throw new Error("initializeWasm() must be awaited first!");
11502 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
11503 // debug statements here
11505 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
11507 export function CVec_OutPointZ_free(_res: number): void {
11508 if(!isWasmInitialized) {
11509 throw new Error("initializeWasm() must be awaited first!");
11511 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
11512 // debug statements here
11514 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
11516 export function CResult_NoneAPIErrorZ_ok(): number {
11517 if(!isWasmInitialized) {
11518 throw new Error("initializeWasm() must be awaited first!");
11520 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11521 return nativeResponseValue;
11523 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11525 export function CResult_NoneAPIErrorZ_err(e: number): number {
11526 if(!isWasmInitialized) {
11527 throw new Error("initializeWasm() must be awaited first!");
11529 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11530 return nativeResponseValue;
11532 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11534 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
11535 if(!isWasmInitialized) {
11536 throw new Error("initializeWasm() must be awaited first!");
11538 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11539 return nativeResponseValue;
11541 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11543 export function CResult_NoneAPIErrorZ_free(_res: number): void {
11544 if(!isWasmInitialized) {
11545 throw new Error("initializeWasm() must be awaited first!");
11547 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11548 // debug statements here
11550 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11552 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
11553 if(!isWasmInitialized) {
11554 throw new Error("initializeWasm() must be awaited first!");
11556 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11557 return nativeResponseValue;
11559 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11561 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
11562 if(!isWasmInitialized) {
11563 throw new Error("initializeWasm() must be awaited first!");
11565 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11566 return nativeResponseValue;
11568 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
11570 export function COption_u16Z_some(o: number): number {
11571 if(!isWasmInitialized) {
11572 throw new Error("initializeWasm() must be awaited first!");
11574 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
11575 return nativeResponseValue;
11577 // struct LDKCOption_u16Z COption_u16Z_none(void);
11579 export function COption_u16Z_none(): number {
11580 if(!isWasmInitialized) {
11581 throw new Error("initializeWasm() must be awaited first!");
11583 const nativeResponseValue = wasm.TS_COption_u16Z_none();
11584 return nativeResponseValue;
11586 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
11588 export function COption_u16Z_free(_res: number): void {
11589 if(!isWasmInitialized) {
11590 throw new Error("initializeWasm() must be awaited first!");
11592 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
11593 // debug statements here
11595 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
11597 export function COption_u16Z_clone_ptr(arg: number): number {
11598 if(!isWasmInitialized) {
11599 throw new Error("initializeWasm() must be awaited first!");
11601 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
11602 return nativeResponseValue;
11604 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
11606 export function COption_u16Z_clone(orig: number): number {
11607 if(!isWasmInitialized) {
11608 throw new Error("initializeWasm() must be awaited first!");
11610 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
11611 return nativeResponseValue;
11613 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11615 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11616 if(!isWasmInitialized) {
11617 throw new Error("initializeWasm() must be awaited first!");
11619 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11620 // debug statements here
11622 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11624 export function CVec_APIErrorZ_free(_res: number): void {
11625 if(!isWasmInitialized) {
11626 throw new Error("initializeWasm() must be awaited first!");
11628 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11629 // debug statements here
11631 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11633 export function CResult__u832APIErrorZ_ok(o: number): number {
11634 if(!isWasmInitialized) {
11635 throw new Error("initializeWasm() must be awaited first!");
11637 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11638 return nativeResponseValue;
11640 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11642 export function CResult__u832APIErrorZ_err(e: number): number {
11643 if(!isWasmInitialized) {
11644 throw new Error("initializeWasm() must be awaited first!");
11646 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11647 return nativeResponseValue;
11649 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11651 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
11652 if(!isWasmInitialized) {
11653 throw new Error("initializeWasm() must be awaited first!");
11655 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11656 return nativeResponseValue;
11658 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11660 export function CResult__u832APIErrorZ_free(_res: number): void {
11661 if(!isWasmInitialized) {
11662 throw new Error("initializeWasm() must be awaited first!");
11664 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11665 // debug statements here
11667 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11669 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
11670 if(!isWasmInitialized) {
11671 throw new Error("initializeWasm() must be awaited first!");
11673 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11674 return nativeResponseValue;
11676 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11678 export function CResult__u832APIErrorZ_clone(orig: number): number {
11679 if(!isWasmInitialized) {
11680 throw new Error("initializeWasm() must be awaited first!");
11682 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
11683 return nativeResponseValue;
11685 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
11687 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
11688 if(!isWasmInitialized) {
11689 throw new Error("initializeWasm() must be awaited first!");
11691 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
11692 return nativeResponseValue;
11694 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11696 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
11697 if(!isWasmInitialized) {
11698 throw new Error("initializeWasm() must be awaited first!");
11700 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
11701 return nativeResponseValue;
11703 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
11705 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
11706 if(!isWasmInitialized) {
11707 throw new Error("initializeWasm() must be awaited first!");
11709 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
11710 return nativeResponseValue;
11712 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
11714 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
11715 if(!isWasmInitialized) {
11716 throw new Error("initializeWasm() must be awaited first!");
11718 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
11719 // debug statements here
11721 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
11723 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
11724 if(!isWasmInitialized) {
11725 throw new Error("initializeWasm() must be awaited first!");
11727 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
11728 return nativeResponseValue;
11730 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
11732 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
11733 if(!isWasmInitialized) {
11734 throw new Error("initializeWasm() must be awaited first!");
11736 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
11737 return nativeResponseValue;
11739 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
11741 export function CResult_NonePaymentSendFailureZ_ok(): number {
11742 if(!isWasmInitialized) {
11743 throw new Error("initializeWasm() must be awaited first!");
11745 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
11746 return nativeResponseValue;
11748 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11750 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
11751 if(!isWasmInitialized) {
11752 throw new Error("initializeWasm() must be awaited first!");
11754 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
11755 return nativeResponseValue;
11757 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
11759 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
11760 if(!isWasmInitialized) {
11761 throw new Error("initializeWasm() must be awaited first!");
11763 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
11764 return nativeResponseValue;
11766 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
11768 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
11769 if(!isWasmInitialized) {
11770 throw new Error("initializeWasm() must be awaited first!");
11772 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
11773 // debug statements here
11775 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
11777 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
11778 if(!isWasmInitialized) {
11779 throw new Error("initializeWasm() must be awaited first!");
11781 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
11782 return nativeResponseValue;
11784 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
11786 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
11787 if(!isWasmInitialized) {
11788 throw new Error("initializeWasm() must be awaited first!");
11790 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
11791 return nativeResponseValue;
11793 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
11795 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
11796 if(!isWasmInitialized) {
11797 throw new Error("initializeWasm() must be awaited first!");
11799 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
11800 return nativeResponseValue;
11802 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
11804 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
11805 if(!isWasmInitialized) {
11806 throw new Error("initializeWasm() must be awaited first!");
11808 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
11809 return nativeResponseValue;
11811 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11813 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
11814 if(!isWasmInitialized) {
11815 throw new Error("initializeWasm() must be awaited first!");
11817 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
11818 return nativeResponseValue;
11820 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
11822 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
11823 if(!isWasmInitialized) {
11824 throw new Error("initializeWasm() must be awaited first!");
11826 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
11827 // debug statements here
11829 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
11831 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
11832 if(!isWasmInitialized) {
11833 throw new Error("initializeWasm() must be awaited first!");
11835 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
11836 return nativeResponseValue;
11838 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11840 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
11841 if(!isWasmInitialized) {
11842 throw new Error("initializeWasm() must be awaited first!");
11844 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
11845 return nativeResponseValue;
11847 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
11849 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
11850 if(!isWasmInitialized) {
11851 throw new Error("initializeWasm() must be awaited first!");
11853 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
11854 return nativeResponseValue;
11856 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
11858 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
11859 if(!isWasmInitialized) {
11860 throw new Error("initializeWasm() must be awaited first!");
11862 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
11863 // debug statements here
11865 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
11867 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
11868 if(!isWasmInitialized) {
11869 throw new Error("initializeWasm() must be awaited first!");
11871 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
11872 return nativeResponseValue;
11874 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
11876 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
11877 if(!isWasmInitialized) {
11878 throw new Error("initializeWasm() must be awaited first!");
11880 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
11881 return nativeResponseValue;
11883 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
11885 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
11886 if(!isWasmInitialized) {
11887 throw new Error("initializeWasm() must be awaited first!");
11889 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
11890 return nativeResponseValue;
11892 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
11894 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
11895 if(!isWasmInitialized) {
11896 throw new Error("initializeWasm() must be awaited first!");
11898 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
11899 return nativeResponseValue;
11901 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11903 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
11904 if(!isWasmInitialized) {
11905 throw new Error("initializeWasm() must be awaited first!");
11907 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
11908 return nativeResponseValue;
11910 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11912 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
11913 if(!isWasmInitialized) {
11914 throw new Error("initializeWasm() must be awaited first!");
11916 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11917 // debug statements here
11919 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11921 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
11922 if(!isWasmInitialized) {
11923 throw new Error("initializeWasm() must be awaited first!");
11925 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11926 return nativeResponseValue;
11928 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11930 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
11931 if(!isWasmInitialized) {
11932 throw new Error("initializeWasm() must be awaited first!");
11934 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11935 return nativeResponseValue;
11937 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11939 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
11940 if(!isWasmInitialized) {
11941 throw new Error("initializeWasm() must be awaited first!");
11943 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11944 return nativeResponseValue;
11946 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11948 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
11949 if(!isWasmInitialized) {
11950 throw new Error("initializeWasm() must be awaited first!");
11952 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11953 // debug statements here
11955 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11957 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
11958 if(!isWasmInitialized) {
11959 throw new Error("initializeWasm() must be awaited first!");
11961 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11962 return nativeResponseValue;
11964 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11966 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
11967 if(!isWasmInitialized) {
11968 throw new Error("initializeWasm() must be awaited first!");
11970 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11971 return nativeResponseValue;
11973 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11975 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
11976 if(!isWasmInitialized) {
11977 throw new Error("initializeWasm() must be awaited first!");
11979 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11980 return nativeResponseValue;
11982 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11984 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
11985 if(!isWasmInitialized) {
11986 throw new Error("initializeWasm() must be awaited first!");
11988 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11989 return nativeResponseValue;
11991 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11993 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
11994 if(!isWasmInitialized) {
11995 throw new Error("initializeWasm() must be awaited first!");
11997 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11998 return nativeResponseValue;
12000 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
12002 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
12003 if(!isWasmInitialized) {
12004 throw new Error("initializeWasm() must be awaited first!");
12006 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
12007 // debug statements here
12009 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
12011 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
12012 if(!isWasmInitialized) {
12013 throw new Error("initializeWasm() must be awaited first!");
12015 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
12016 return nativeResponseValue;
12018 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
12020 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
12021 if(!isWasmInitialized) {
12022 throw new Error("initializeWasm() must be awaited first!");
12024 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
12025 return nativeResponseValue;
12027 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12029 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
12030 if(!isWasmInitialized) {
12031 throw new Error("initializeWasm() must be awaited first!");
12033 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
12034 return nativeResponseValue;
12036 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
12038 export function CResult_PaymentSecretNoneZ_err(): number {
12039 if(!isWasmInitialized) {
12040 throw new Error("initializeWasm() must be awaited first!");
12042 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
12043 return nativeResponseValue;
12045 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
12047 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
12048 if(!isWasmInitialized) {
12049 throw new Error("initializeWasm() must be awaited first!");
12051 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
12052 return nativeResponseValue;
12054 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
12056 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
12057 if(!isWasmInitialized) {
12058 throw new Error("initializeWasm() must be awaited first!");
12060 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
12061 // debug statements here
12063 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
12065 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
12066 if(!isWasmInitialized) {
12067 throw new Error("initializeWasm() must be awaited first!");
12069 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
12070 return nativeResponseValue;
12072 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
12074 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
12075 if(!isWasmInitialized) {
12076 throw new Error("initializeWasm() must be awaited first!");
12078 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
12079 return nativeResponseValue;
12081 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12083 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
12084 if(!isWasmInitialized) {
12085 throw new Error("initializeWasm() must be awaited first!");
12087 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
12088 return nativeResponseValue;
12090 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
12092 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
12093 if(!isWasmInitialized) {
12094 throw new Error("initializeWasm() must be awaited first!");
12096 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
12097 return nativeResponseValue;
12099 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
12101 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
12102 if(!isWasmInitialized) {
12103 throw new Error("initializeWasm() must be awaited first!");
12105 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
12106 return nativeResponseValue;
12108 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
12110 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
12111 if(!isWasmInitialized) {
12112 throw new Error("initializeWasm() must be awaited first!");
12114 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
12115 // debug statements here
12117 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
12119 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
12120 if(!isWasmInitialized) {
12121 throw new Error("initializeWasm() must be awaited first!");
12123 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
12124 return nativeResponseValue;
12126 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
12128 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
12129 if(!isWasmInitialized) {
12130 throw new Error("initializeWasm() must be awaited first!");
12132 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
12133 return nativeResponseValue;
12135 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12137 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
12138 if(!isWasmInitialized) {
12139 throw new Error("initializeWasm() must be awaited first!");
12141 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
12142 return nativeResponseValue;
12144 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
12146 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
12147 if(!isWasmInitialized) {
12148 throw new Error("initializeWasm() must be awaited first!");
12150 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
12151 return nativeResponseValue;
12153 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
12155 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
12156 if(!isWasmInitialized) {
12157 throw new Error("initializeWasm() must be awaited first!");
12159 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
12160 return nativeResponseValue;
12162 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
12164 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
12165 if(!isWasmInitialized) {
12166 throw new Error("initializeWasm() must be awaited first!");
12168 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
12169 // debug statements here
12171 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
12173 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
12174 if(!isWasmInitialized) {
12175 throw new Error("initializeWasm() must be awaited first!");
12177 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
12178 return nativeResponseValue;
12180 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
12182 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
12183 if(!isWasmInitialized) {
12184 throw new Error("initializeWasm() must be awaited first!");
12186 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
12187 return nativeResponseValue;
12189 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
12191 export function CVec_ChannelMonitorZ_free(_res: number): void {
12192 if(!isWasmInitialized) {
12193 throw new Error("initializeWasm() must be awaited first!");
12195 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
12196 // debug statements here
12198 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
12200 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
12201 if(!isWasmInitialized) {
12202 throw new Error("initializeWasm() must be awaited first!");
12204 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
12205 return nativeResponseValue;
12207 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
12209 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
12210 if(!isWasmInitialized) {
12211 throw new Error("initializeWasm() must be awaited first!");
12213 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
12214 // debug statements here
12216 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
12218 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
12219 if(!isWasmInitialized) {
12220 throw new Error("initializeWasm() must be awaited first!");
12222 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
12223 return nativeResponseValue;
12225 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
12227 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
12228 if(!isWasmInitialized) {
12229 throw new Error("initializeWasm() must be awaited first!");
12231 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
12232 return nativeResponseValue;
12234 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
12236 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
12237 if(!isWasmInitialized) {
12238 throw new Error("initializeWasm() must be awaited first!");
12240 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
12241 return nativeResponseValue;
12243 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
12245 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
12246 if(!isWasmInitialized) {
12247 throw new Error("initializeWasm() must be awaited first!");
12249 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
12250 // debug statements here
12252 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
12254 export function PaymentPurpose_free(this_ptr: number): void {
12255 if(!isWasmInitialized) {
12256 throw new Error("initializeWasm() must be awaited first!");
12258 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
12259 // debug statements here
12261 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
12263 export function PaymentPurpose_clone_ptr(arg: number): number {
12264 if(!isWasmInitialized) {
12265 throw new Error("initializeWasm() must be awaited first!");
12267 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
12268 return nativeResponseValue;
12270 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
12272 export function PaymentPurpose_clone(orig: number): number {
12273 if(!isWasmInitialized) {
12274 throw new Error("initializeWasm() must be awaited first!");
12276 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
12277 return nativeResponseValue;
12279 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
12281 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
12282 if(!isWasmInitialized) {
12283 throw new Error("initializeWasm() must be awaited first!");
12285 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
12286 return nativeResponseValue;
12288 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
12290 export function PaymentPurpose_spontaneous_payment(a: number): number {
12291 if(!isWasmInitialized) {
12292 throw new Error("initializeWasm() must be awaited first!");
12294 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
12295 return nativeResponseValue;
12297 // void ClosureReason_free(struct LDKClosureReason this_ptr);
12299 export function ClosureReason_free(this_ptr: number): void {
12300 if(!isWasmInitialized) {
12301 throw new Error("initializeWasm() must be awaited first!");
12303 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
12304 // debug statements here
12306 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
12308 export function ClosureReason_clone_ptr(arg: number): number {
12309 if(!isWasmInitialized) {
12310 throw new Error("initializeWasm() must be awaited first!");
12312 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
12313 return nativeResponseValue;
12315 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
12317 export function ClosureReason_clone(orig: number): number {
12318 if(!isWasmInitialized) {
12319 throw new Error("initializeWasm() must be awaited first!");
12321 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
12322 return nativeResponseValue;
12324 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
12326 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
12327 if(!isWasmInitialized) {
12328 throw new Error("initializeWasm() must be awaited first!");
12330 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
12331 return nativeResponseValue;
12333 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
12335 export function ClosureReason_holder_force_closed(): number {
12336 if(!isWasmInitialized) {
12337 throw new Error("initializeWasm() must be awaited first!");
12339 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
12340 return nativeResponseValue;
12342 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
12344 export function ClosureReason_cooperative_closure(): number {
12345 if(!isWasmInitialized) {
12346 throw new Error("initializeWasm() must be awaited first!");
12348 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
12349 return nativeResponseValue;
12351 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
12353 export function ClosureReason_commitment_tx_confirmed(): number {
12354 if(!isWasmInitialized) {
12355 throw new Error("initializeWasm() must be awaited first!");
12357 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
12358 return nativeResponseValue;
12360 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
12362 export function ClosureReason_funding_timed_out(): number {
12363 if(!isWasmInitialized) {
12364 throw new Error("initializeWasm() must be awaited first!");
12366 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
12367 return nativeResponseValue;
12369 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
12371 export function ClosureReason_processing_error(err: number): number {
12372 if(!isWasmInitialized) {
12373 throw new Error("initializeWasm() must be awaited first!");
12375 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
12376 return nativeResponseValue;
12378 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
12380 export function ClosureReason_disconnected_peer(): number {
12381 if(!isWasmInitialized) {
12382 throw new Error("initializeWasm() must be awaited first!");
12384 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
12385 return nativeResponseValue;
12387 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
12389 export function ClosureReason_outdated_channel_manager(): number {
12390 if(!isWasmInitialized) {
12391 throw new Error("initializeWasm() must be awaited first!");
12393 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
12394 return nativeResponseValue;
12396 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
12398 export function ClosureReason_write(obj: number): number {
12399 if(!isWasmInitialized) {
12400 throw new Error("initializeWasm() must be awaited first!");
12402 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
12403 return nativeResponseValue;
12405 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
12407 export function ClosureReason_read(ser: number): number {
12408 if(!isWasmInitialized) {
12409 throw new Error("initializeWasm() must be awaited first!");
12411 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
12412 return nativeResponseValue;
12414 // void Event_free(struct LDKEvent this_ptr);
12416 export function Event_free(this_ptr: number): void {
12417 if(!isWasmInitialized) {
12418 throw new Error("initializeWasm() must be awaited first!");
12420 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
12421 // debug statements here
12423 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
12425 export function Event_clone_ptr(arg: number): number {
12426 if(!isWasmInitialized) {
12427 throw new Error("initializeWasm() must be awaited first!");
12429 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
12430 return nativeResponseValue;
12432 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
12434 export function Event_clone(orig: number): number {
12435 if(!isWasmInitialized) {
12436 throw new Error("initializeWasm() must be awaited first!");
12438 const nativeResponseValue = wasm.TS_Event_clone(orig);
12439 return nativeResponseValue;
12441 // 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);
12443 export function Event_funding_generation_ready(temporary_channel_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): number {
12444 if(!isWasmInitialized) {
12445 throw new Error("initializeWasm() must be awaited first!");
12447 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
12448 return nativeResponseValue;
12450 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
12452 export function Event_payment_received(payment_hash: number, amt: bigint, purpose: number): number {
12453 if(!isWasmInitialized) {
12454 throw new Error("initializeWasm() must be awaited first!");
12456 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amt, purpose);
12457 return nativeResponseValue;
12459 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
12461 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
12462 if(!isWasmInitialized) {
12463 throw new Error("initializeWasm() must be awaited first!");
12465 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
12466 return nativeResponseValue;
12468 // struct LDKEvent Event_payment_path_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, bool rejected_by_dest, struct LDKCOption_NetworkUpdateZ network_update, bool all_paths_failed, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id, struct LDKRouteParameters retry);
12470 export function Event_payment_path_failed(payment_id: number, payment_hash: number, rejected_by_dest: boolean, network_update: number, all_paths_failed: boolean, path: number, short_channel_id: number, retry: number): number {
12471 if(!isWasmInitialized) {
12472 throw new Error("initializeWasm() must be awaited first!");
12474 const nativeResponseValue = wasm.TS_Event_payment_path_failed(payment_id, payment_hash, rejected_by_dest, network_update, all_paths_failed, path, short_channel_id, retry);
12475 return nativeResponseValue;
12477 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
12479 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
12480 if(!isWasmInitialized) {
12481 throw new Error("initializeWasm() must be awaited first!");
12483 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
12484 return nativeResponseValue;
12486 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
12488 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
12489 if(!isWasmInitialized) {
12490 throw new Error("initializeWasm() must be awaited first!");
12492 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
12493 return nativeResponseValue;
12495 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
12497 export function Event_spendable_outputs(outputs: number): number {
12498 if(!isWasmInitialized) {
12499 throw new Error("initializeWasm() must be awaited first!");
12501 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
12502 return nativeResponseValue;
12504 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
12506 export function Event_payment_forwarded(fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
12507 if(!isWasmInitialized) {
12508 throw new Error("initializeWasm() must be awaited first!");
12510 const nativeResponseValue = wasm.TS_Event_payment_forwarded(fee_earned_msat, claim_from_onchain_tx);
12511 return nativeResponseValue;
12513 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
12515 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
12516 if(!isWasmInitialized) {
12517 throw new Error("initializeWasm() must be awaited first!");
12519 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
12520 return nativeResponseValue;
12522 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
12524 export function Event_discard_funding(channel_id: number, transaction: number): number {
12525 if(!isWasmInitialized) {
12526 throw new Error("initializeWasm() must be awaited first!");
12528 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
12529 return nativeResponseValue;
12531 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
12533 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
12534 if(!isWasmInitialized) {
12535 throw new Error("initializeWasm() must be awaited first!");
12537 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
12538 return nativeResponseValue;
12540 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
12542 export function Event_write(obj: number): number {
12543 if(!isWasmInitialized) {
12544 throw new Error("initializeWasm() must be awaited first!");
12546 const nativeResponseValue = wasm.TS_Event_write(obj);
12547 return nativeResponseValue;
12549 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
12551 export function Event_read(ser: number): number {
12552 if(!isWasmInitialized) {
12553 throw new Error("initializeWasm() must be awaited first!");
12555 const nativeResponseValue = wasm.TS_Event_read(ser);
12556 return nativeResponseValue;
12558 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
12560 export function MessageSendEvent_free(this_ptr: number): void {
12561 if(!isWasmInitialized) {
12562 throw new Error("initializeWasm() must be awaited first!");
12564 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
12565 // debug statements here
12567 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
12569 export function MessageSendEvent_clone_ptr(arg: number): number {
12570 if(!isWasmInitialized) {
12571 throw new Error("initializeWasm() must be awaited first!");
12573 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
12574 return nativeResponseValue;
12576 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
12578 export function MessageSendEvent_clone(orig: number): number {
12579 if(!isWasmInitialized) {
12580 throw new Error("initializeWasm() must be awaited first!");
12582 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
12583 return nativeResponseValue;
12585 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
12587 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
12588 if(!isWasmInitialized) {
12589 throw new Error("initializeWasm() must be awaited first!");
12591 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
12592 return nativeResponseValue;
12594 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
12596 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
12597 if(!isWasmInitialized) {
12598 throw new Error("initializeWasm() must be awaited first!");
12600 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
12601 return nativeResponseValue;
12603 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
12605 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
12606 if(!isWasmInitialized) {
12607 throw new Error("initializeWasm() must be awaited first!");
12609 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
12610 return nativeResponseValue;
12612 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
12614 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
12615 if(!isWasmInitialized) {
12616 throw new Error("initializeWasm() must be awaited first!");
12618 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
12619 return nativeResponseValue;
12621 // struct LDKMessageSendEvent MessageSendEvent_send_funding_locked(struct LDKPublicKey node_id, struct LDKFundingLocked msg);
12623 export function MessageSendEvent_send_funding_locked(node_id: number, msg: number): number {
12624 if(!isWasmInitialized) {
12625 throw new Error("initializeWasm() must be awaited first!");
12627 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_locked(node_id, msg);
12628 return nativeResponseValue;
12630 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
12632 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
12633 if(!isWasmInitialized) {
12634 throw new Error("initializeWasm() must be awaited first!");
12636 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
12637 return nativeResponseValue;
12639 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
12641 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
12642 if(!isWasmInitialized) {
12643 throw new Error("initializeWasm() must be awaited first!");
12645 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
12646 return nativeResponseValue;
12648 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
12650 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
12651 if(!isWasmInitialized) {
12652 throw new Error("initializeWasm() must be awaited first!");
12654 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
12655 return nativeResponseValue;
12657 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
12659 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
12660 if(!isWasmInitialized) {
12661 throw new Error("initializeWasm() must be awaited first!");
12663 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
12664 return nativeResponseValue;
12666 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
12668 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
12669 if(!isWasmInitialized) {
12670 throw new Error("initializeWasm() must be awaited first!");
12672 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
12673 return nativeResponseValue;
12675 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
12677 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
12678 if(!isWasmInitialized) {
12679 throw new Error("initializeWasm() must be awaited first!");
12681 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
12682 return nativeResponseValue;
12684 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
12686 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
12687 if(!isWasmInitialized) {
12688 throw new Error("initializeWasm() must be awaited first!");
12690 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
12691 return nativeResponseValue;
12693 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
12695 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
12696 if(!isWasmInitialized) {
12697 throw new Error("initializeWasm() must be awaited first!");
12699 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
12700 return nativeResponseValue;
12702 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
12704 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
12705 if(!isWasmInitialized) {
12706 throw new Error("initializeWasm() must be awaited first!");
12708 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
12709 return nativeResponseValue;
12711 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
12713 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
12714 if(!isWasmInitialized) {
12715 throw new Error("initializeWasm() must be awaited first!");
12717 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
12718 return nativeResponseValue;
12720 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
12722 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
12723 if(!isWasmInitialized) {
12724 throw new Error("initializeWasm() must be awaited first!");
12726 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
12727 return nativeResponseValue;
12729 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
12731 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
12732 if(!isWasmInitialized) {
12733 throw new Error("initializeWasm() must be awaited first!");
12735 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
12736 return nativeResponseValue;
12738 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
12740 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
12741 if(!isWasmInitialized) {
12742 throw new Error("initializeWasm() must be awaited first!");
12744 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
12745 return nativeResponseValue;
12747 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
12749 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
12750 if(!isWasmInitialized) {
12751 throw new Error("initializeWasm() must be awaited first!");
12753 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
12754 return nativeResponseValue;
12756 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
12758 export function MessageSendEventsProvider_free(this_ptr: number): void {
12759 if(!isWasmInitialized) {
12760 throw new Error("initializeWasm() must be awaited first!");
12762 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
12763 // debug statements here
12765 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
12767 export function EventsProvider_free(this_ptr: number): void {
12768 if(!isWasmInitialized) {
12769 throw new Error("initializeWasm() must be awaited first!");
12771 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
12772 // debug statements here
12774 // void EventHandler_free(struct LDKEventHandler this_ptr);
12776 export function EventHandler_free(this_ptr: number): void {
12777 if(!isWasmInitialized) {
12778 throw new Error("initializeWasm() must be awaited first!");
12780 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
12781 // debug statements here
12783 // void APIError_free(struct LDKAPIError this_ptr);
12785 export function APIError_free(this_ptr: number): void {
12786 if(!isWasmInitialized) {
12787 throw new Error("initializeWasm() must be awaited first!");
12789 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
12790 // debug statements here
12792 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
12794 export function APIError_clone_ptr(arg: number): number {
12795 if(!isWasmInitialized) {
12796 throw new Error("initializeWasm() must be awaited first!");
12798 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
12799 return nativeResponseValue;
12801 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
12803 export function APIError_clone(orig: number): number {
12804 if(!isWasmInitialized) {
12805 throw new Error("initializeWasm() must be awaited first!");
12807 const nativeResponseValue = wasm.TS_APIError_clone(orig);
12808 return nativeResponseValue;
12810 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
12812 export function APIError_apimisuse_error(err: number): number {
12813 if(!isWasmInitialized) {
12814 throw new Error("initializeWasm() must be awaited first!");
12816 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
12817 return nativeResponseValue;
12819 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
12821 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
12822 if(!isWasmInitialized) {
12823 throw new Error("initializeWasm() must be awaited first!");
12825 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
12826 return nativeResponseValue;
12828 // struct LDKAPIError APIError_route_error(struct LDKStr err);
12830 export function APIError_route_error(err: number): number {
12831 if(!isWasmInitialized) {
12832 throw new Error("initializeWasm() must be awaited first!");
12834 const nativeResponseValue = wasm.TS_APIError_route_error(err);
12835 return nativeResponseValue;
12837 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
12839 export function APIError_channel_unavailable(err: number): number {
12840 if(!isWasmInitialized) {
12841 throw new Error("initializeWasm() must be awaited first!");
12843 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
12844 return nativeResponseValue;
12846 // struct LDKAPIError APIError_monitor_update_failed(void);
12848 export function APIError_monitor_update_failed(): number {
12849 if(!isWasmInitialized) {
12850 throw new Error("initializeWasm() must be awaited first!");
12852 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
12853 return nativeResponseValue;
12855 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
12857 export function APIError_incompatible_shutdown_script(script: number): number {
12858 if(!isWasmInitialized) {
12859 throw new Error("initializeWasm() must be awaited first!");
12861 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
12862 return nativeResponseValue;
12864 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
12866 export function sign(msg: number, sk: number): number {
12867 if(!isWasmInitialized) {
12868 throw new Error("initializeWasm() must be awaited first!");
12870 const nativeResponseValue = wasm.TS_sign(msg, sk);
12871 return nativeResponseValue;
12873 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
12875 export function recover_pk(msg: number, sig: number): number {
12876 if(!isWasmInitialized) {
12877 throw new Error("initializeWasm() must be awaited first!");
12879 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
12880 return nativeResponseValue;
12882 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
12884 export function verify(msg: number, sig: number, pk: number): boolean {
12885 if(!isWasmInitialized) {
12886 throw new Error("initializeWasm() must be awaited first!");
12888 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
12889 return nativeResponseValue;
12891 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
12893 export function Level_clone(orig: number): Level {
12894 if(!isWasmInitialized) {
12895 throw new Error("initializeWasm() must be awaited first!");
12897 const nativeResponseValue = wasm.TS_Level_clone(orig);
12898 return nativeResponseValue;
12900 // enum LDKLevel Level_gossip(void);
12902 export function Level_gossip(): Level {
12903 if(!isWasmInitialized) {
12904 throw new Error("initializeWasm() must be awaited first!");
12906 const nativeResponseValue = wasm.TS_Level_gossip();
12907 return nativeResponseValue;
12909 // enum LDKLevel Level_trace(void);
12911 export function Level_trace(): Level {
12912 if(!isWasmInitialized) {
12913 throw new Error("initializeWasm() must be awaited first!");
12915 const nativeResponseValue = wasm.TS_Level_trace();
12916 return nativeResponseValue;
12918 // enum LDKLevel Level_debug(void);
12920 export function Level_debug(): Level {
12921 if(!isWasmInitialized) {
12922 throw new Error("initializeWasm() must be awaited first!");
12924 const nativeResponseValue = wasm.TS_Level_debug();
12925 return nativeResponseValue;
12927 // enum LDKLevel Level_info(void);
12929 export function Level_info(): Level {
12930 if(!isWasmInitialized) {
12931 throw new Error("initializeWasm() must be awaited first!");
12933 const nativeResponseValue = wasm.TS_Level_info();
12934 return nativeResponseValue;
12936 // enum LDKLevel Level_warn(void);
12938 export function Level_warn(): Level {
12939 if(!isWasmInitialized) {
12940 throw new Error("initializeWasm() must be awaited first!");
12942 const nativeResponseValue = wasm.TS_Level_warn();
12943 return nativeResponseValue;
12945 // enum LDKLevel Level_error(void);
12947 export function Level_error(): Level {
12948 if(!isWasmInitialized) {
12949 throw new Error("initializeWasm() must be awaited first!");
12951 const nativeResponseValue = wasm.TS_Level_error();
12952 return nativeResponseValue;
12954 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
12956 export function Level_eq(a: number, b: number): boolean {
12957 if(!isWasmInitialized) {
12958 throw new Error("initializeWasm() must be awaited first!");
12960 const nativeResponseValue = wasm.TS_Level_eq(a, b);
12961 return nativeResponseValue;
12963 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
12965 export function Level_hash(o: number): bigint {
12966 if(!isWasmInitialized) {
12967 throw new Error("initializeWasm() must be awaited first!");
12969 const nativeResponseValue = wasm.TS_Level_hash(o);
12970 return nativeResponseValue;
12972 // MUST_USE_RES enum LDKLevel Level_max(void);
12974 export function Level_max(): Level {
12975 if(!isWasmInitialized) {
12976 throw new Error("initializeWasm() must be awaited first!");
12978 const nativeResponseValue = wasm.TS_Level_max();
12979 return nativeResponseValue;
12981 // void Record_free(struct LDKRecord this_obj);
12983 export function Record_free(this_obj: number): void {
12984 if(!isWasmInitialized) {
12985 throw new Error("initializeWasm() must be awaited first!");
12987 const nativeResponseValue = wasm.TS_Record_free(this_obj);
12988 // debug statements here
12990 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
12992 export function Record_get_level(this_ptr: number): Level {
12993 if(!isWasmInitialized) {
12994 throw new Error("initializeWasm() must be awaited first!");
12996 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
12997 return nativeResponseValue;
12999 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
13001 export function Record_set_level(this_ptr: number, val: Level): void {
13002 if(!isWasmInitialized) {
13003 throw new Error("initializeWasm() must be awaited first!");
13005 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
13006 // debug statements here
13008 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
13010 export function Record_get_args(this_ptr: number): number {
13011 if(!isWasmInitialized) {
13012 throw new Error("initializeWasm() must be awaited first!");
13014 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
13015 return nativeResponseValue;
13017 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
13019 export function Record_set_args(this_ptr: number, val: number): void {
13020 if(!isWasmInitialized) {
13021 throw new Error("initializeWasm() must be awaited first!");
13023 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
13024 // debug statements here
13026 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
13028 export function Record_get_module_path(this_ptr: number): number {
13029 if(!isWasmInitialized) {
13030 throw new Error("initializeWasm() must be awaited first!");
13032 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
13033 return nativeResponseValue;
13035 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
13037 export function Record_set_module_path(this_ptr: number, val: number): void {
13038 if(!isWasmInitialized) {
13039 throw new Error("initializeWasm() must be awaited first!");
13041 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
13042 // debug statements here
13044 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
13046 export function Record_get_file(this_ptr: number): number {
13047 if(!isWasmInitialized) {
13048 throw new Error("initializeWasm() must be awaited first!");
13050 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
13051 return nativeResponseValue;
13053 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
13055 export function Record_set_file(this_ptr: number, val: number): void {
13056 if(!isWasmInitialized) {
13057 throw new Error("initializeWasm() must be awaited first!");
13059 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
13060 // debug statements here
13062 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
13064 export function Record_get_line(this_ptr: number): number {
13065 if(!isWasmInitialized) {
13066 throw new Error("initializeWasm() must be awaited first!");
13068 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
13069 return nativeResponseValue;
13071 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
13073 export function Record_set_line(this_ptr: number, val: number): void {
13074 if(!isWasmInitialized) {
13075 throw new Error("initializeWasm() must be awaited first!");
13077 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
13078 // debug statements here
13080 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
13082 export function Record_clone_ptr(arg: number): number {
13083 if(!isWasmInitialized) {
13084 throw new Error("initializeWasm() must be awaited first!");
13086 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
13087 return nativeResponseValue;
13089 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
13091 export function Record_clone(orig: number): number {
13092 if(!isWasmInitialized) {
13093 throw new Error("initializeWasm() must be awaited first!");
13095 const nativeResponseValue = wasm.TS_Record_clone(orig);
13096 return nativeResponseValue;
13098 // void Logger_free(struct LDKLogger this_ptr);
13100 export function Logger_free(this_ptr: number): void {
13101 if(!isWasmInitialized) {
13102 throw new Error("initializeWasm() must be awaited first!");
13104 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
13105 // debug statements here
13107 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
13109 export function ChannelHandshakeConfig_free(this_obj: number): void {
13110 if(!isWasmInitialized) {
13111 throw new Error("initializeWasm() must be awaited first!");
13113 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
13114 // debug statements here
13116 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
13118 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
13119 if(!isWasmInitialized) {
13120 throw new Error("initializeWasm() must be awaited first!");
13122 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
13123 return nativeResponseValue;
13125 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
13127 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
13128 if(!isWasmInitialized) {
13129 throw new Error("initializeWasm() must be awaited first!");
13131 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
13132 // debug statements here
13134 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
13136 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
13137 if(!isWasmInitialized) {
13138 throw new Error("initializeWasm() must be awaited first!");
13140 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
13141 return nativeResponseValue;
13143 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
13145 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
13146 if(!isWasmInitialized) {
13147 throw new Error("initializeWasm() must be awaited first!");
13149 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
13150 // debug statements here
13152 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
13154 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
13155 if(!isWasmInitialized) {
13156 throw new Error("initializeWasm() must be awaited first!");
13158 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
13159 return nativeResponseValue;
13161 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
13163 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
13164 if(!isWasmInitialized) {
13165 throw new Error("initializeWasm() must be awaited first!");
13167 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
13168 // debug statements here
13170 // 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);
13172 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint): number {
13173 if(!isWasmInitialized) {
13174 throw new Error("initializeWasm() must be awaited first!");
13176 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
13177 return nativeResponseValue;
13179 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
13181 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
13182 if(!isWasmInitialized) {
13183 throw new Error("initializeWasm() must be awaited first!");
13185 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
13186 return nativeResponseValue;
13188 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
13190 export function ChannelHandshakeConfig_clone(orig: number): number {
13191 if(!isWasmInitialized) {
13192 throw new Error("initializeWasm() must be awaited first!");
13194 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
13195 return nativeResponseValue;
13197 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
13199 export function ChannelHandshakeConfig_default(): number {
13200 if(!isWasmInitialized) {
13201 throw new Error("initializeWasm() must be awaited first!");
13203 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
13204 return nativeResponseValue;
13206 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
13208 export function ChannelHandshakeLimits_free(this_obj: number): void {
13209 if(!isWasmInitialized) {
13210 throw new Error("initializeWasm() must be awaited first!");
13212 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
13213 // debug statements here
13215 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13217 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
13218 if(!isWasmInitialized) {
13219 throw new Error("initializeWasm() must be awaited first!");
13221 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
13222 return nativeResponseValue;
13224 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13226 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
13227 if(!isWasmInitialized) {
13228 throw new Error("initializeWasm() must be awaited first!");
13230 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
13231 // debug statements here
13233 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13235 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
13236 if(!isWasmInitialized) {
13237 throw new Error("initializeWasm() must be awaited first!");
13239 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
13240 return nativeResponseValue;
13242 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13244 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
13245 if(!isWasmInitialized) {
13246 throw new Error("initializeWasm() must be awaited first!");
13248 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
13249 // debug statements here
13251 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13253 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
13254 if(!isWasmInitialized) {
13255 throw new Error("initializeWasm() must be awaited first!");
13257 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
13258 return nativeResponseValue;
13260 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13262 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
13263 if(!isWasmInitialized) {
13264 throw new Error("initializeWasm() must be awaited first!");
13266 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
13267 // debug statements here
13269 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13271 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
13272 if(!isWasmInitialized) {
13273 throw new Error("initializeWasm() must be awaited first!");
13275 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
13276 return nativeResponseValue;
13278 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13280 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
13281 if(!isWasmInitialized) {
13282 throw new Error("initializeWasm() must be awaited first!");
13284 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
13285 // debug statements here
13287 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13289 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
13290 if(!isWasmInitialized) {
13291 throw new Error("initializeWasm() must be awaited first!");
13293 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
13294 return nativeResponseValue;
13296 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
13298 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
13299 if(!isWasmInitialized) {
13300 throw new Error("initializeWasm() must be awaited first!");
13302 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
13303 // debug statements here
13305 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13307 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
13308 if(!isWasmInitialized) {
13309 throw new Error("initializeWasm() must be awaited first!");
13311 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
13312 return nativeResponseValue;
13314 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
13316 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
13317 if(!isWasmInitialized) {
13318 throw new Error("initializeWasm() must be awaited first!");
13320 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
13321 // debug statements here
13323 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13325 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
13326 if(!isWasmInitialized) {
13327 throw new Error("initializeWasm() must be awaited first!");
13329 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
13330 return nativeResponseValue;
13332 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
13334 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
13335 if(!isWasmInitialized) {
13336 throw new Error("initializeWasm() must be awaited first!");
13338 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
13339 // debug statements here
13341 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13343 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
13344 if(!isWasmInitialized) {
13345 throw new Error("initializeWasm() must be awaited first!");
13347 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
13348 return nativeResponseValue;
13350 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
13352 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
13353 if(!isWasmInitialized) {
13354 throw new Error("initializeWasm() must be awaited first!");
13356 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
13357 // debug statements here
13359 // 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);
13361 export function ChannelHandshakeLimits_new(min_funding_satoshis_arg: bigint, max_htlc_minimum_msat_arg: bigint, min_max_htlc_value_in_flight_msat_arg: bigint, max_channel_reserve_satoshis_arg: bigint, min_max_accepted_htlcs_arg: number, max_minimum_depth_arg: number, force_announced_channel_preference_arg: boolean, their_to_self_delay_arg: number): number {
13362 if(!isWasmInitialized) {
13363 throw new Error("initializeWasm() must be awaited first!");
13365 const nativeResponseValue = wasm.TS_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);
13366 return nativeResponseValue;
13368 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
13370 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
13371 if(!isWasmInitialized) {
13372 throw new Error("initializeWasm() must be awaited first!");
13374 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
13375 return nativeResponseValue;
13377 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
13379 export function ChannelHandshakeLimits_clone(orig: number): number {
13380 if(!isWasmInitialized) {
13381 throw new Error("initializeWasm() must be awaited first!");
13383 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
13384 return nativeResponseValue;
13386 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
13388 export function ChannelHandshakeLimits_default(): number {
13389 if(!isWasmInitialized) {
13390 throw new Error("initializeWasm() must be awaited first!");
13392 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
13393 return nativeResponseValue;
13395 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
13397 export function ChannelConfig_free(this_obj: number): void {
13398 if(!isWasmInitialized) {
13399 throw new Error("initializeWasm() must be awaited first!");
13401 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
13402 // debug statements here
13404 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13406 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
13407 if(!isWasmInitialized) {
13408 throw new Error("initializeWasm() must be awaited first!");
13410 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
13411 return nativeResponseValue;
13413 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
13415 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
13416 if(!isWasmInitialized) {
13417 throw new Error("initializeWasm() must be awaited first!");
13419 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
13420 // debug statements here
13422 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13424 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
13425 if(!isWasmInitialized) {
13426 throw new Error("initializeWasm() must be awaited first!");
13428 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
13429 return nativeResponseValue;
13431 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
13433 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
13434 if(!isWasmInitialized) {
13435 throw new Error("initializeWasm() must be awaited first!");
13437 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
13438 // debug statements here
13440 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13442 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
13443 if(!isWasmInitialized) {
13444 throw new Error("initializeWasm() must be awaited first!");
13446 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
13447 return nativeResponseValue;
13449 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
13451 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
13452 if(!isWasmInitialized) {
13453 throw new Error("initializeWasm() must be awaited first!");
13455 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
13456 // debug statements here
13458 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13460 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
13461 if(!isWasmInitialized) {
13462 throw new Error("initializeWasm() must be awaited first!");
13464 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
13465 return nativeResponseValue;
13467 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
13469 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
13470 if(!isWasmInitialized) {
13471 throw new Error("initializeWasm() must be awaited first!");
13473 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
13474 // debug statements here
13476 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13478 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
13479 if(!isWasmInitialized) {
13480 throw new Error("initializeWasm() must be awaited first!");
13482 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
13483 return nativeResponseValue;
13485 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
13487 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
13488 if(!isWasmInitialized) {
13489 throw new Error("initializeWasm() must be awaited first!");
13491 const nativeResponseValue = wasm.TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
13492 // debug statements here
13494 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13496 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
13497 if(!isWasmInitialized) {
13498 throw new Error("initializeWasm() must be awaited first!");
13500 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
13501 return nativeResponseValue;
13503 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
13505 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
13506 if(!isWasmInitialized) {
13507 throw new Error("initializeWasm() must be awaited first!");
13509 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
13510 // debug statements here
13512 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13514 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
13515 if(!isWasmInitialized) {
13516 throw new Error("initializeWasm() must be awaited first!");
13518 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
13519 return nativeResponseValue;
13521 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
13523 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
13524 if(!isWasmInitialized) {
13525 throw new Error("initializeWasm() must be awaited first!");
13527 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
13528 // debug statements here
13530 // 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);
13532 export function ChannelConfig_new(forwarding_fee_proportional_millionths_arg: number, forwarding_fee_base_msat_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): number {
13533 if(!isWasmInitialized) {
13534 throw new Error("initializeWasm() must be awaited first!");
13536 const nativeResponseValue = wasm.TS_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);
13537 return nativeResponseValue;
13539 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
13541 export function ChannelConfig_clone_ptr(arg: number): number {
13542 if(!isWasmInitialized) {
13543 throw new Error("initializeWasm() must be awaited first!");
13545 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
13546 return nativeResponseValue;
13548 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
13550 export function ChannelConfig_clone(orig: number): number {
13551 if(!isWasmInitialized) {
13552 throw new Error("initializeWasm() must be awaited first!");
13554 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
13555 return nativeResponseValue;
13557 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
13559 export function ChannelConfig_default(): number {
13560 if(!isWasmInitialized) {
13561 throw new Error("initializeWasm() must be awaited first!");
13563 const nativeResponseValue = wasm.TS_ChannelConfig_default();
13564 return nativeResponseValue;
13566 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
13568 export function ChannelConfig_write(obj: number): number {
13569 if(!isWasmInitialized) {
13570 throw new Error("initializeWasm() must be awaited first!");
13572 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
13573 return nativeResponseValue;
13575 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
13577 export function ChannelConfig_read(ser: number): number {
13578 if(!isWasmInitialized) {
13579 throw new Error("initializeWasm() must be awaited first!");
13581 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
13582 return nativeResponseValue;
13584 // void UserConfig_free(struct LDKUserConfig this_obj);
13586 export function UserConfig_free(this_obj: number): void {
13587 if(!isWasmInitialized) {
13588 throw new Error("initializeWasm() must be awaited first!");
13590 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
13591 // debug statements here
13593 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13595 export function UserConfig_get_own_channel_config(this_ptr: number): number {
13596 if(!isWasmInitialized) {
13597 throw new Error("initializeWasm() must be awaited first!");
13599 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
13600 return nativeResponseValue;
13602 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
13604 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
13605 if(!isWasmInitialized) {
13606 throw new Error("initializeWasm() must be awaited first!");
13608 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
13609 // debug statements here
13611 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13613 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
13614 if(!isWasmInitialized) {
13615 throw new Error("initializeWasm() must be awaited first!");
13617 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
13618 return nativeResponseValue;
13620 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
13622 export function UserConfig_set_peer_channel_config_limits(this_ptr: number, val: number): void {
13623 if(!isWasmInitialized) {
13624 throw new Error("initializeWasm() must be awaited first!");
13626 const nativeResponseValue = wasm.TS_UserConfig_set_peer_channel_config_limits(this_ptr, val);
13627 // debug statements here
13629 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13631 export function UserConfig_get_channel_options(this_ptr: number): number {
13632 if(!isWasmInitialized) {
13633 throw new Error("initializeWasm() must be awaited first!");
13635 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
13636 return nativeResponseValue;
13638 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
13640 export function UserConfig_set_channel_options(this_ptr: number, val: number): void {
13641 if(!isWasmInitialized) {
13642 throw new Error("initializeWasm() must be awaited first!");
13644 const nativeResponseValue = wasm.TS_UserConfig_set_channel_options(this_ptr, val);
13645 // debug statements here
13647 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13649 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
13650 if(!isWasmInitialized) {
13651 throw new Error("initializeWasm() must be awaited first!");
13653 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
13654 return nativeResponseValue;
13656 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
13658 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
13659 if(!isWasmInitialized) {
13660 throw new Error("initializeWasm() must be awaited first!");
13662 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
13663 // debug statements here
13665 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13667 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
13668 if(!isWasmInitialized) {
13669 throw new Error("initializeWasm() must be awaited first!");
13671 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
13672 return nativeResponseValue;
13674 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
13676 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
13677 if(!isWasmInitialized) {
13678 throw new Error("initializeWasm() must be awaited first!");
13680 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
13681 // debug statements here
13683 // 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, bool accept_inbound_channels_arg);
13685 export function UserConfig_new(own_channel_config_arg: number, peer_channel_config_limits_arg: number, channel_options_arg: number, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean): number {
13686 if(!isWasmInitialized) {
13687 throw new Error("initializeWasm() must be awaited first!");
13689 const nativeResponseValue = wasm.TS_UserConfig_new(own_channel_config_arg, peer_channel_config_limits_arg, channel_options_arg, accept_forwards_to_priv_channels_arg, accept_inbound_channels_arg);
13690 return nativeResponseValue;
13692 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
13694 export function UserConfig_clone_ptr(arg: number): number {
13695 if(!isWasmInitialized) {
13696 throw new Error("initializeWasm() must be awaited first!");
13698 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
13699 return nativeResponseValue;
13701 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
13703 export function UserConfig_clone(orig: number): number {
13704 if(!isWasmInitialized) {
13705 throw new Error("initializeWasm() must be awaited first!");
13707 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
13708 return nativeResponseValue;
13710 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
13712 export function UserConfig_default(): number {
13713 if(!isWasmInitialized) {
13714 throw new Error("initializeWasm() must be awaited first!");
13716 const nativeResponseValue = wasm.TS_UserConfig_default();
13717 return nativeResponseValue;
13719 // void BestBlock_free(struct LDKBestBlock this_obj);
13721 export function BestBlock_free(this_obj: number): void {
13722 if(!isWasmInitialized) {
13723 throw new Error("initializeWasm() must be awaited first!");
13725 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
13726 // debug statements here
13728 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
13730 export function BestBlock_clone_ptr(arg: number): number {
13731 if(!isWasmInitialized) {
13732 throw new Error("initializeWasm() must be awaited first!");
13734 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
13735 return nativeResponseValue;
13737 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
13739 export function BestBlock_clone(orig: number): number {
13740 if(!isWasmInitialized) {
13741 throw new Error("initializeWasm() must be awaited first!");
13743 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
13744 return nativeResponseValue;
13746 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
13748 export function BestBlock_from_genesis(network: Network): number {
13749 if(!isWasmInitialized) {
13750 throw new Error("initializeWasm() must be awaited first!");
13752 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
13753 return nativeResponseValue;
13755 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
13757 export function BestBlock_new(block_hash: number, height: number): number {
13758 if(!isWasmInitialized) {
13759 throw new Error("initializeWasm() must be awaited first!");
13761 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
13762 return nativeResponseValue;
13764 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
13766 export function BestBlock_block_hash(this_arg: number): number {
13767 if(!isWasmInitialized) {
13768 throw new Error("initializeWasm() must be awaited first!");
13770 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
13771 return nativeResponseValue;
13773 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
13775 export function BestBlock_height(this_arg: number): number {
13776 if(!isWasmInitialized) {
13777 throw new Error("initializeWasm() must be awaited first!");
13779 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
13780 return nativeResponseValue;
13782 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
13784 export function AccessError_clone(orig: number): AccessError {
13785 if(!isWasmInitialized) {
13786 throw new Error("initializeWasm() must be awaited first!");
13788 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
13789 return nativeResponseValue;
13791 // enum LDKAccessError AccessError_unknown_chain(void);
13793 export function AccessError_unknown_chain(): AccessError {
13794 if(!isWasmInitialized) {
13795 throw new Error("initializeWasm() must be awaited first!");
13797 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
13798 return nativeResponseValue;
13800 // enum LDKAccessError AccessError_unknown_tx(void);
13802 export function AccessError_unknown_tx(): AccessError {
13803 if(!isWasmInitialized) {
13804 throw new Error("initializeWasm() must be awaited first!");
13806 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
13807 return nativeResponseValue;
13809 // void Access_free(struct LDKAccess this_ptr);
13811 export function Access_free(this_ptr: number): void {
13812 if(!isWasmInitialized) {
13813 throw new Error("initializeWasm() must be awaited first!");
13815 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
13816 // debug statements here
13818 // void Listen_free(struct LDKListen this_ptr);
13820 export function Listen_free(this_ptr: number): void {
13821 if(!isWasmInitialized) {
13822 throw new Error("initializeWasm() must be awaited first!");
13824 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
13825 // debug statements here
13827 // void Confirm_free(struct LDKConfirm this_ptr);
13829 export function Confirm_free(this_ptr: number): void {
13830 if(!isWasmInitialized) {
13831 throw new Error("initializeWasm() must be awaited first!");
13833 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
13834 // debug statements here
13836 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
13838 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
13839 if(!isWasmInitialized) {
13840 throw new Error("initializeWasm() must be awaited first!");
13842 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
13843 return nativeResponseValue;
13845 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
13847 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
13848 if(!isWasmInitialized) {
13849 throw new Error("initializeWasm() must be awaited first!");
13851 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
13852 return nativeResponseValue;
13854 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
13856 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
13857 if(!isWasmInitialized) {
13858 throw new Error("initializeWasm() must be awaited first!");
13860 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
13861 return nativeResponseValue;
13863 // void Watch_free(struct LDKWatch this_ptr);
13865 export function Watch_free(this_ptr: number): void {
13866 if(!isWasmInitialized) {
13867 throw new Error("initializeWasm() must be awaited first!");
13869 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
13870 // debug statements here
13872 // void Filter_free(struct LDKFilter this_ptr);
13874 export function Filter_free(this_ptr: number): void {
13875 if(!isWasmInitialized) {
13876 throw new Error("initializeWasm() must be awaited first!");
13878 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
13879 // debug statements here
13881 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
13883 export function WatchedOutput_free(this_obj: number): void {
13884 if(!isWasmInitialized) {
13885 throw new Error("initializeWasm() must be awaited first!");
13887 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
13888 // debug statements here
13890 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
13892 export function WatchedOutput_get_block_hash(this_ptr: number): number {
13893 if(!isWasmInitialized) {
13894 throw new Error("initializeWasm() must be awaited first!");
13896 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
13897 return nativeResponseValue;
13899 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
13901 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
13902 if(!isWasmInitialized) {
13903 throw new Error("initializeWasm() must be awaited first!");
13905 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
13906 // debug statements here
13908 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
13910 export function WatchedOutput_get_outpoint(this_ptr: number): number {
13911 if(!isWasmInitialized) {
13912 throw new Error("initializeWasm() must be awaited first!");
13914 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
13915 return nativeResponseValue;
13917 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
13919 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
13920 if(!isWasmInitialized) {
13921 throw new Error("initializeWasm() must be awaited first!");
13923 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
13924 // debug statements here
13926 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
13928 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
13929 if(!isWasmInitialized) {
13930 throw new Error("initializeWasm() must be awaited first!");
13932 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
13933 return nativeResponseValue;
13935 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
13937 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
13938 if(!isWasmInitialized) {
13939 throw new Error("initializeWasm() must be awaited first!");
13941 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
13942 // debug statements here
13944 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
13946 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
13947 if(!isWasmInitialized) {
13948 throw new Error("initializeWasm() must be awaited first!");
13950 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
13951 return nativeResponseValue;
13953 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
13955 export function WatchedOutput_clone_ptr(arg: number): number {
13956 if(!isWasmInitialized) {
13957 throw new Error("initializeWasm() must be awaited first!");
13959 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
13960 return nativeResponseValue;
13962 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
13964 export function WatchedOutput_clone(orig: number): number {
13965 if(!isWasmInitialized) {
13966 throw new Error("initializeWasm() must be awaited first!");
13968 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
13969 return nativeResponseValue;
13971 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
13973 export function WatchedOutput_hash(o: number): bigint {
13974 if(!isWasmInitialized) {
13975 throw new Error("initializeWasm() must be awaited first!");
13977 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
13978 return nativeResponseValue;
13980 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
13982 export function BroadcasterInterface_free(this_ptr: number): void {
13983 if(!isWasmInitialized) {
13984 throw new Error("initializeWasm() must be awaited first!");
13986 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
13987 // debug statements here
13989 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
13991 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
13992 if(!isWasmInitialized) {
13993 throw new Error("initializeWasm() must be awaited first!");
13995 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
13996 return nativeResponseValue;
13998 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
14000 export function ConfirmationTarget_background(): ConfirmationTarget {
14001 if(!isWasmInitialized) {
14002 throw new Error("initializeWasm() must be awaited first!");
14004 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
14005 return nativeResponseValue;
14007 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
14009 export function ConfirmationTarget_normal(): ConfirmationTarget {
14010 if(!isWasmInitialized) {
14011 throw new Error("initializeWasm() must be awaited first!");
14013 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
14014 return nativeResponseValue;
14016 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
14018 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
14019 if(!isWasmInitialized) {
14020 throw new Error("initializeWasm() must be awaited first!");
14022 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
14023 return nativeResponseValue;
14025 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
14027 export function ConfirmationTarget_eq(a: number, b: number): boolean {
14028 if(!isWasmInitialized) {
14029 throw new Error("initializeWasm() must be awaited first!");
14031 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
14032 return nativeResponseValue;
14034 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
14036 export function FeeEstimator_free(this_ptr: number): void {
14037 if(!isWasmInitialized) {
14038 throw new Error("initializeWasm() must be awaited first!");
14040 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
14041 // debug statements here
14043 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
14045 export function MonitorUpdateId_free(this_obj: number): void {
14046 if(!isWasmInitialized) {
14047 throw new Error("initializeWasm() must be awaited first!");
14049 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
14050 // debug statements here
14052 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
14054 export function MonitorUpdateId_clone_ptr(arg: number): number {
14055 if(!isWasmInitialized) {
14056 throw new Error("initializeWasm() must be awaited first!");
14058 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
14059 return nativeResponseValue;
14061 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
14063 export function MonitorUpdateId_clone(orig: number): number {
14064 if(!isWasmInitialized) {
14065 throw new Error("initializeWasm() must be awaited first!");
14067 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
14068 return nativeResponseValue;
14070 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
14072 export function MonitorUpdateId_hash(o: number): bigint {
14073 if(!isWasmInitialized) {
14074 throw new Error("initializeWasm() must be awaited first!");
14076 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
14077 return nativeResponseValue;
14079 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
14081 export function MonitorUpdateId_eq(a: number, b: number): boolean {
14082 if(!isWasmInitialized) {
14083 throw new Error("initializeWasm() must be awaited first!");
14085 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
14086 return nativeResponseValue;
14088 // void Persist_free(struct LDKPersist this_ptr);
14090 export function Persist_free(this_ptr: number): void {
14091 if(!isWasmInitialized) {
14092 throw new Error("initializeWasm() must be awaited first!");
14094 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
14095 // debug statements here
14097 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
14099 export function LockedChannelMonitor_free(this_obj: number): void {
14100 if(!isWasmInitialized) {
14101 throw new Error("initializeWasm() must be awaited first!");
14103 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
14104 // debug statements here
14106 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
14108 export function ChainMonitor_free(this_obj: number): void {
14109 if(!isWasmInitialized) {
14110 throw new Error("initializeWasm() must be awaited first!");
14112 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
14113 // debug statements here
14115 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
14117 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
14118 if(!isWasmInitialized) {
14119 throw new Error("initializeWasm() must be awaited first!");
14121 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
14122 return nativeResponseValue;
14124 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
14126 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
14127 if(!isWasmInitialized) {
14128 throw new Error("initializeWasm() must be awaited first!");
14130 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
14131 return nativeResponseValue;
14133 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
14135 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
14136 if(!isWasmInitialized) {
14137 throw new Error("initializeWasm() must be awaited first!");
14139 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
14140 return nativeResponseValue;
14142 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14144 export function ChainMonitor_list_monitors(this_arg: number): number {
14145 if(!isWasmInitialized) {
14146 throw new Error("initializeWasm() must be awaited first!");
14148 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
14149 return nativeResponseValue;
14151 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChainMonitor_channel_monitor_updated(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKMonitorUpdateId completed_update_id);
14153 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
14154 if(!isWasmInitialized) {
14155 throw new Error("initializeWasm() must be awaited first!");
14157 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
14158 return nativeResponseValue;
14160 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14162 export function ChainMonitor_as_Listen(this_arg: number): number {
14163 if(!isWasmInitialized) {
14164 throw new Error("initializeWasm() must be awaited first!");
14166 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
14167 return nativeResponseValue;
14169 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14171 export function ChainMonitor_as_Confirm(this_arg: number): number {
14172 if(!isWasmInitialized) {
14173 throw new Error("initializeWasm() must be awaited first!");
14175 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
14176 return nativeResponseValue;
14178 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14180 export function ChainMonitor_as_Watch(this_arg: number): number {
14181 if(!isWasmInitialized) {
14182 throw new Error("initializeWasm() must be awaited first!");
14184 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
14185 return nativeResponseValue;
14187 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14189 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
14190 if(!isWasmInitialized) {
14191 throw new Error("initializeWasm() must be awaited first!");
14193 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
14194 return nativeResponseValue;
14196 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
14198 export function ChannelMonitorUpdate_free(this_obj: number): void {
14199 if(!isWasmInitialized) {
14200 throw new Error("initializeWasm() must be awaited first!");
14202 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
14203 // debug statements here
14205 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
14207 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
14208 if(!isWasmInitialized) {
14209 throw new Error("initializeWasm() must be awaited first!");
14211 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
14212 return nativeResponseValue;
14214 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
14216 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
14217 if(!isWasmInitialized) {
14218 throw new Error("initializeWasm() must be awaited first!");
14220 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
14221 // debug statements here
14223 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
14225 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
14226 if(!isWasmInitialized) {
14227 throw new Error("initializeWasm() must be awaited first!");
14229 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
14230 return nativeResponseValue;
14232 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
14234 export function ChannelMonitorUpdate_clone(orig: number): number {
14235 if(!isWasmInitialized) {
14236 throw new Error("initializeWasm() must be awaited first!");
14238 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
14239 return nativeResponseValue;
14241 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
14243 export function ChannelMonitorUpdate_write(obj: number): number {
14244 if(!isWasmInitialized) {
14245 throw new Error("initializeWasm() must be awaited first!");
14247 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
14248 return nativeResponseValue;
14250 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
14252 export function ChannelMonitorUpdate_read(ser: number): number {
14253 if(!isWasmInitialized) {
14254 throw new Error("initializeWasm() must be awaited first!");
14256 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
14257 return nativeResponseValue;
14259 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
14261 export function MonitorEvent_free(this_ptr: number): void {
14262 if(!isWasmInitialized) {
14263 throw new Error("initializeWasm() must be awaited first!");
14265 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
14266 // debug statements here
14268 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
14270 export function MonitorEvent_clone_ptr(arg: number): number {
14271 if(!isWasmInitialized) {
14272 throw new Error("initializeWasm() must be awaited first!");
14274 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
14275 return nativeResponseValue;
14277 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
14279 export function MonitorEvent_clone(orig: number): number {
14280 if(!isWasmInitialized) {
14281 throw new Error("initializeWasm() must be awaited first!");
14283 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
14284 return nativeResponseValue;
14286 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
14288 export function MonitorEvent_htlcevent(a: number): number {
14289 if(!isWasmInitialized) {
14290 throw new Error("initializeWasm() must be awaited first!");
14292 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
14293 return nativeResponseValue;
14295 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
14297 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
14298 if(!isWasmInitialized) {
14299 throw new Error("initializeWasm() must be awaited first!");
14301 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
14302 return nativeResponseValue;
14304 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
14306 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
14307 if(!isWasmInitialized) {
14308 throw new Error("initializeWasm() must be awaited first!");
14310 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
14311 return nativeResponseValue;
14313 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
14315 export function MonitorEvent_update_failed(a: number): number {
14316 if(!isWasmInitialized) {
14317 throw new Error("initializeWasm() must be awaited first!");
14319 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
14320 return nativeResponseValue;
14322 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
14324 export function MonitorEvent_write(obj: number): number {
14325 if(!isWasmInitialized) {
14326 throw new Error("initializeWasm() must be awaited first!");
14328 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
14329 return nativeResponseValue;
14331 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
14333 export function MonitorEvent_read(ser: number): number {
14334 if(!isWasmInitialized) {
14335 throw new Error("initializeWasm() must be awaited first!");
14337 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
14338 return nativeResponseValue;
14340 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
14342 export function HTLCUpdate_free(this_obj: number): void {
14343 if(!isWasmInitialized) {
14344 throw new Error("initializeWasm() must be awaited first!");
14346 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
14347 // debug statements here
14349 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
14351 export function HTLCUpdate_clone_ptr(arg: number): number {
14352 if(!isWasmInitialized) {
14353 throw new Error("initializeWasm() must be awaited first!");
14355 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
14356 return nativeResponseValue;
14358 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
14360 export function HTLCUpdate_clone(orig: number): number {
14361 if(!isWasmInitialized) {
14362 throw new Error("initializeWasm() must be awaited first!");
14364 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
14365 return nativeResponseValue;
14367 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
14369 export function HTLCUpdate_write(obj: number): number {
14370 if(!isWasmInitialized) {
14371 throw new Error("initializeWasm() must be awaited first!");
14373 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
14374 return nativeResponseValue;
14376 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
14378 export function HTLCUpdate_read(ser: number): number {
14379 if(!isWasmInitialized) {
14380 throw new Error("initializeWasm() must be awaited first!");
14382 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
14383 return nativeResponseValue;
14385 // void Balance_free(struct LDKBalance this_ptr);
14387 export function Balance_free(this_ptr: number): void {
14388 if(!isWasmInitialized) {
14389 throw new Error("initializeWasm() must be awaited first!");
14391 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
14392 // debug statements here
14394 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
14396 export function Balance_clone_ptr(arg: number): number {
14397 if(!isWasmInitialized) {
14398 throw new Error("initializeWasm() must be awaited first!");
14400 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
14401 return nativeResponseValue;
14403 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
14405 export function Balance_clone(orig: number): number {
14406 if(!isWasmInitialized) {
14407 throw new Error("initializeWasm() must be awaited first!");
14409 const nativeResponseValue = wasm.TS_Balance_clone(orig);
14410 return nativeResponseValue;
14412 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
14414 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
14415 if(!isWasmInitialized) {
14416 throw new Error("initializeWasm() must be awaited first!");
14418 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
14419 return nativeResponseValue;
14421 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
14423 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
14424 if(!isWasmInitialized) {
14425 throw new Error("initializeWasm() must be awaited first!");
14427 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
14428 return nativeResponseValue;
14430 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
14432 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
14433 if(!isWasmInitialized) {
14434 throw new Error("initializeWasm() must be awaited first!");
14436 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
14437 return nativeResponseValue;
14439 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
14441 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
14442 if(!isWasmInitialized) {
14443 throw new Error("initializeWasm() must be awaited first!");
14445 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
14446 return nativeResponseValue;
14448 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
14450 export function Balance_eq(a: number, b: number): boolean {
14451 if(!isWasmInitialized) {
14452 throw new Error("initializeWasm() must be awaited first!");
14454 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
14455 return nativeResponseValue;
14457 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
14459 export function ChannelMonitor_free(this_obj: number): void {
14460 if(!isWasmInitialized) {
14461 throw new Error("initializeWasm() must be awaited first!");
14463 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
14464 // debug statements here
14466 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
14468 export function ChannelMonitor_clone_ptr(arg: number): number {
14469 if(!isWasmInitialized) {
14470 throw new Error("initializeWasm() must be awaited first!");
14472 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
14473 return nativeResponseValue;
14475 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
14477 export function ChannelMonitor_clone(orig: number): number {
14478 if(!isWasmInitialized) {
14479 throw new Error("initializeWasm() must be awaited first!");
14481 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
14482 return nativeResponseValue;
14484 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
14486 export function ChannelMonitor_write(obj: number): number {
14487 if(!isWasmInitialized) {
14488 throw new Error("initializeWasm() must be awaited first!");
14490 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
14491 return nativeResponseValue;
14493 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
14495 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
14496 if(!isWasmInitialized) {
14497 throw new Error("initializeWasm() must be awaited first!");
14499 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
14500 return nativeResponseValue;
14502 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14504 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
14505 if(!isWasmInitialized) {
14506 throw new Error("initializeWasm() must be awaited first!");
14508 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
14509 return nativeResponseValue;
14511 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14513 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
14514 if(!isWasmInitialized) {
14515 throw new Error("initializeWasm() must be awaited first!");
14517 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
14518 return nativeResponseValue;
14520 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14522 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
14523 if(!isWasmInitialized) {
14524 throw new Error("initializeWasm() must be awaited first!");
14526 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
14527 return nativeResponseValue;
14529 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
14531 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
14532 if(!isWasmInitialized) {
14533 throw new Error("initializeWasm() must be awaited first!");
14535 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
14536 // debug statements here
14538 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14540 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
14541 if(!isWasmInitialized) {
14542 throw new Error("initializeWasm() must be awaited first!");
14544 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
14545 return nativeResponseValue;
14547 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14549 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
14550 if(!isWasmInitialized) {
14551 throw new Error("initializeWasm() must be awaited first!");
14553 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
14554 return nativeResponseValue;
14556 // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger);
14558 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
14559 if(!isWasmInitialized) {
14560 throw new Error("initializeWasm() must be awaited first!");
14562 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
14563 return nativeResponseValue;
14565 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
14567 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
14568 if(!isWasmInitialized) {
14569 throw new Error("initializeWasm() must be awaited first!");
14571 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
14572 return nativeResponseValue;
14574 // void ChannelMonitor_block_disconnected(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
14576 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
14577 if(!isWasmInitialized) {
14578 throw new Error("initializeWasm() must be awaited first!");
14580 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
14581 // debug statements here
14583 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_transactions_confirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
14585 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
14586 if(!isWasmInitialized) {
14587 throw new Error("initializeWasm() must be awaited first!");
14589 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
14590 return nativeResponseValue;
14592 // void ChannelMonitor_transaction_unconfirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
14594 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
14595 if(!isWasmInitialized) {
14596 throw new Error("initializeWasm() must be awaited first!");
14598 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
14599 // debug statements here
14601 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_best_block_updated(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
14603 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
14604 if(!isWasmInitialized) {
14605 throw new Error("initializeWasm() must be awaited first!");
14607 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
14608 return nativeResponseValue;
14610 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14612 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
14613 if(!isWasmInitialized) {
14614 throw new Error("initializeWasm() must be awaited first!");
14616 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
14617 return nativeResponseValue;
14619 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14621 export function ChannelMonitor_current_best_block(this_arg: number): number {
14622 if(!isWasmInitialized) {
14623 throw new Error("initializeWasm() must be awaited first!");
14625 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
14626 return nativeResponseValue;
14628 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14630 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
14631 if(!isWasmInitialized) {
14632 throw new Error("initializeWasm() must be awaited first!");
14634 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
14635 return nativeResponseValue;
14637 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
14639 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
14640 if(!isWasmInitialized) {
14641 throw new Error("initializeWasm() must be awaited first!");
14643 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
14644 return nativeResponseValue;
14646 // void OutPoint_free(struct LDKOutPoint this_obj);
14648 export function OutPoint_free(this_obj: number): void {
14649 if(!isWasmInitialized) {
14650 throw new Error("initializeWasm() must be awaited first!");
14652 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
14653 // debug statements here
14655 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
14657 export function OutPoint_get_txid(this_ptr: number): number {
14658 if(!isWasmInitialized) {
14659 throw new Error("initializeWasm() must be awaited first!");
14661 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
14662 return nativeResponseValue;
14664 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
14666 export function OutPoint_set_txid(this_ptr: number, val: number): void {
14667 if(!isWasmInitialized) {
14668 throw new Error("initializeWasm() must be awaited first!");
14670 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
14671 // debug statements here
14673 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
14675 export function OutPoint_get_index(this_ptr: number): number {
14676 if(!isWasmInitialized) {
14677 throw new Error("initializeWasm() must be awaited first!");
14679 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
14680 return nativeResponseValue;
14682 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
14684 export function OutPoint_set_index(this_ptr: number, val: number): void {
14685 if(!isWasmInitialized) {
14686 throw new Error("initializeWasm() must be awaited first!");
14688 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
14689 // debug statements here
14691 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
14693 export function OutPoint_new(txid_arg: number, index_arg: number): number {
14694 if(!isWasmInitialized) {
14695 throw new Error("initializeWasm() must be awaited first!");
14697 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
14698 return nativeResponseValue;
14700 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
14702 export function OutPoint_clone_ptr(arg: number): number {
14703 if(!isWasmInitialized) {
14704 throw new Error("initializeWasm() must be awaited first!");
14706 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
14707 return nativeResponseValue;
14709 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
14711 export function OutPoint_clone(orig: number): number {
14712 if(!isWasmInitialized) {
14713 throw new Error("initializeWasm() must be awaited first!");
14715 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
14716 return nativeResponseValue;
14718 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
14720 export function OutPoint_eq(a: number, b: number): boolean {
14721 if(!isWasmInitialized) {
14722 throw new Error("initializeWasm() must be awaited first!");
14724 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
14725 return nativeResponseValue;
14727 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
14729 export function OutPoint_hash(o: number): bigint {
14730 if(!isWasmInitialized) {
14731 throw new Error("initializeWasm() must be awaited first!");
14733 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
14734 return nativeResponseValue;
14736 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
14738 export function OutPoint_to_channel_id(this_arg: number): number {
14739 if(!isWasmInitialized) {
14740 throw new Error("initializeWasm() must be awaited first!");
14742 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
14743 return nativeResponseValue;
14745 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
14747 export function OutPoint_write(obj: number): number {
14748 if(!isWasmInitialized) {
14749 throw new Error("initializeWasm() must be awaited first!");
14751 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
14752 return nativeResponseValue;
14754 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
14756 export function OutPoint_read(ser: number): number {
14757 if(!isWasmInitialized) {
14758 throw new Error("initializeWasm() must be awaited first!");
14760 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
14761 return nativeResponseValue;
14763 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
14765 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
14766 if(!isWasmInitialized) {
14767 throw new Error("initializeWasm() must be awaited first!");
14769 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
14770 // debug statements here
14772 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14774 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
14775 if(!isWasmInitialized) {
14776 throw new Error("initializeWasm() must be awaited first!");
14778 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
14779 return nativeResponseValue;
14781 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
14783 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
14784 if(!isWasmInitialized) {
14785 throw new Error("initializeWasm() must be awaited first!");
14787 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
14788 // debug statements here
14790 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14792 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
14793 if(!isWasmInitialized) {
14794 throw new Error("initializeWasm() must be awaited first!");
14796 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
14797 return nativeResponseValue;
14799 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
14801 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
14802 if(!isWasmInitialized) {
14803 throw new Error("initializeWasm() must be awaited first!");
14805 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
14806 // debug statements here
14808 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14810 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
14811 if(!isWasmInitialized) {
14812 throw new Error("initializeWasm() must be awaited first!");
14814 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
14815 return nativeResponseValue;
14817 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
14819 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
14820 if(!isWasmInitialized) {
14821 throw new Error("initializeWasm() must be awaited first!");
14823 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
14824 // debug statements here
14826 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
14828 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
14829 if(!isWasmInitialized) {
14830 throw new Error("initializeWasm() must be awaited first!");
14832 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
14833 // debug statements here
14835 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14837 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
14838 if(!isWasmInitialized) {
14839 throw new Error("initializeWasm() must be awaited first!");
14841 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
14842 return nativeResponseValue;
14844 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
14846 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
14847 if(!isWasmInitialized) {
14848 throw new Error("initializeWasm() must be awaited first!");
14850 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
14851 // debug statements here
14853 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
14855 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
14856 if(!isWasmInitialized) {
14857 throw new Error("initializeWasm() must be awaited first!");
14859 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
14860 return nativeResponseValue;
14862 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
14864 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
14865 if(!isWasmInitialized) {
14866 throw new Error("initializeWasm() must be awaited first!");
14868 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
14869 // debug statements here
14871 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14873 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
14874 if(!isWasmInitialized) {
14875 throw new Error("initializeWasm() must be awaited first!");
14877 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
14878 return nativeResponseValue;
14880 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
14882 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
14883 if(!isWasmInitialized) {
14884 throw new Error("initializeWasm() must be awaited first!");
14886 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
14887 // debug statements here
14889 // 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);
14891 export function DelayedPaymentOutputDescriptor_new(outpoint_arg: number, per_commitment_point_arg: number, to_self_delay_arg: number, output_arg: number, revocation_pubkey_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
14892 if(!isWasmInitialized) {
14893 throw new Error("initializeWasm() must be awaited first!");
14895 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_new(outpoint_arg, per_commitment_point_arg, to_self_delay_arg, output_arg, revocation_pubkey_arg, channel_keys_id_arg, channel_value_satoshis_arg);
14896 return nativeResponseValue;
14898 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
14900 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
14901 if(!isWasmInitialized) {
14902 throw new Error("initializeWasm() must be awaited first!");
14904 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
14905 return nativeResponseValue;
14907 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
14909 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
14910 if(!isWasmInitialized) {
14911 throw new Error("initializeWasm() must be awaited first!");
14913 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
14914 return nativeResponseValue;
14916 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
14918 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
14919 if(!isWasmInitialized) {
14920 throw new Error("initializeWasm() must be awaited first!");
14922 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
14923 return nativeResponseValue;
14925 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
14927 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
14928 if(!isWasmInitialized) {
14929 throw new Error("initializeWasm() must be awaited first!");
14931 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
14932 return nativeResponseValue;
14934 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
14936 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
14937 if(!isWasmInitialized) {
14938 throw new Error("initializeWasm() must be awaited first!");
14940 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
14941 // debug statements here
14943 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14945 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
14946 if(!isWasmInitialized) {
14947 throw new Error("initializeWasm() must be awaited first!");
14949 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
14950 return nativeResponseValue;
14952 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
14954 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
14955 if(!isWasmInitialized) {
14956 throw new Error("initializeWasm() must be awaited first!");
14958 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
14959 // debug statements here
14961 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
14963 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
14964 if(!isWasmInitialized) {
14965 throw new Error("initializeWasm() must be awaited first!");
14967 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
14968 // debug statements here
14970 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
14972 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
14973 if(!isWasmInitialized) {
14974 throw new Error("initializeWasm() must be awaited first!");
14976 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
14977 return nativeResponseValue;
14979 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
14981 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
14982 if(!isWasmInitialized) {
14983 throw new Error("initializeWasm() must be awaited first!");
14985 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
14986 // debug statements here
14988 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14990 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
14991 if(!isWasmInitialized) {
14992 throw new Error("initializeWasm() must be awaited first!");
14994 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
14995 return nativeResponseValue;
14997 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
14999 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
15000 if(!isWasmInitialized) {
15001 throw new Error("initializeWasm() must be awaited first!");
15003 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
15004 // debug statements here
15006 // 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);
15008 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
15009 if(!isWasmInitialized) {
15010 throw new Error("initializeWasm() must be awaited first!");
15012 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
15013 return nativeResponseValue;
15015 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
15017 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
15018 if(!isWasmInitialized) {
15019 throw new Error("initializeWasm() must be awaited first!");
15021 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
15022 return nativeResponseValue;
15024 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
15026 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
15027 if(!isWasmInitialized) {
15028 throw new Error("initializeWasm() must be awaited first!");
15030 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
15031 return nativeResponseValue;
15033 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
15035 export function StaticPaymentOutputDescriptor_write(obj: number): number {
15036 if(!isWasmInitialized) {
15037 throw new Error("initializeWasm() must be awaited first!");
15039 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
15040 return nativeResponseValue;
15042 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
15044 export function StaticPaymentOutputDescriptor_read(ser: number): number {
15045 if(!isWasmInitialized) {
15046 throw new Error("initializeWasm() must be awaited first!");
15048 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
15049 return nativeResponseValue;
15051 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
15053 export function SpendableOutputDescriptor_free(this_ptr: number): void {
15054 if(!isWasmInitialized) {
15055 throw new Error("initializeWasm() must be awaited first!");
15057 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
15058 // debug statements here
15060 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
15062 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
15063 if(!isWasmInitialized) {
15064 throw new Error("initializeWasm() must be awaited first!");
15066 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
15067 return nativeResponseValue;
15069 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
15071 export function SpendableOutputDescriptor_clone(orig: number): number {
15072 if(!isWasmInitialized) {
15073 throw new Error("initializeWasm() must be awaited first!");
15075 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
15076 return nativeResponseValue;
15078 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
15080 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
15081 if(!isWasmInitialized) {
15082 throw new Error("initializeWasm() must be awaited first!");
15084 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
15085 return nativeResponseValue;
15087 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
15089 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
15090 if(!isWasmInitialized) {
15091 throw new Error("initializeWasm() must be awaited first!");
15093 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
15094 return nativeResponseValue;
15096 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
15098 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
15099 if(!isWasmInitialized) {
15100 throw new Error("initializeWasm() must be awaited first!");
15102 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
15103 return nativeResponseValue;
15105 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
15107 export function SpendableOutputDescriptor_write(obj: number): number {
15108 if(!isWasmInitialized) {
15109 throw new Error("initializeWasm() must be awaited first!");
15111 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
15112 return nativeResponseValue;
15114 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
15116 export function SpendableOutputDescriptor_read(ser: number): number {
15117 if(!isWasmInitialized) {
15118 throw new Error("initializeWasm() must be awaited first!");
15120 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
15121 return nativeResponseValue;
15123 // void BaseSign_free(struct LDKBaseSign this_ptr);
15125 export function BaseSign_free(this_ptr: number): void {
15126 if(!isWasmInitialized) {
15127 throw new Error("initializeWasm() must be awaited first!");
15129 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
15130 // debug statements here
15132 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
15134 export function Sign_clone_ptr(arg: number): number {
15135 if(!isWasmInitialized) {
15136 throw new Error("initializeWasm() must be awaited first!");
15138 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
15139 return nativeResponseValue;
15141 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
15143 export function Sign_clone(orig: number): number {
15144 if(!isWasmInitialized) {
15145 throw new Error("initializeWasm() must be awaited first!");
15147 const nativeResponseValue = wasm.TS_Sign_clone(orig);
15148 return nativeResponseValue;
15150 // void Sign_free(struct LDKSign this_ptr);
15152 export function Sign_free(this_ptr: number): void {
15153 if(!isWasmInitialized) {
15154 throw new Error("initializeWasm() must be awaited first!");
15156 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
15157 // debug statements here
15159 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
15161 export function KeysInterface_free(this_ptr: number): void {
15162 if(!isWasmInitialized) {
15163 throw new Error("initializeWasm() must be awaited first!");
15165 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
15166 // debug statements here
15168 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
15170 export function InMemorySigner_free(this_obj: number): void {
15171 if(!isWasmInitialized) {
15172 throw new Error("initializeWasm() must be awaited first!");
15174 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
15175 // debug statements here
15177 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15179 export function InMemorySigner_get_funding_key(this_ptr: number): number {
15180 if(!isWasmInitialized) {
15181 throw new Error("initializeWasm() must be awaited first!");
15183 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
15184 return nativeResponseValue;
15186 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15188 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
15189 if(!isWasmInitialized) {
15190 throw new Error("initializeWasm() must be awaited first!");
15192 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
15193 // debug statements here
15195 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15197 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
15198 if(!isWasmInitialized) {
15199 throw new Error("initializeWasm() must be awaited first!");
15201 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
15202 return nativeResponseValue;
15204 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15206 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
15207 if(!isWasmInitialized) {
15208 throw new Error("initializeWasm() must be awaited first!");
15210 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
15211 // debug statements here
15213 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15215 export function InMemorySigner_get_payment_key(this_ptr: number): number {
15216 if(!isWasmInitialized) {
15217 throw new Error("initializeWasm() must be awaited first!");
15219 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
15220 return nativeResponseValue;
15222 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15224 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
15225 if(!isWasmInitialized) {
15226 throw new Error("initializeWasm() must be awaited first!");
15228 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
15229 // debug statements here
15231 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15233 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
15234 if(!isWasmInitialized) {
15235 throw new Error("initializeWasm() must be awaited first!");
15237 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
15238 return nativeResponseValue;
15240 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15242 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
15243 if(!isWasmInitialized) {
15244 throw new Error("initializeWasm() must be awaited first!");
15246 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
15247 // debug statements here
15249 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15251 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
15252 if(!isWasmInitialized) {
15253 throw new Error("initializeWasm() must be awaited first!");
15255 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
15256 return nativeResponseValue;
15258 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15260 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
15261 if(!isWasmInitialized) {
15262 throw new Error("initializeWasm() must be awaited first!");
15264 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
15265 // debug statements here
15267 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15269 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
15270 if(!isWasmInitialized) {
15271 throw new Error("initializeWasm() must be awaited first!");
15273 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
15274 return nativeResponseValue;
15276 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
15278 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
15279 if(!isWasmInitialized) {
15280 throw new Error("initializeWasm() must be awaited first!");
15282 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
15283 // debug statements here
15285 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
15287 export function InMemorySigner_clone_ptr(arg: number): number {
15288 if(!isWasmInitialized) {
15289 throw new Error("initializeWasm() must be awaited first!");
15291 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
15292 return nativeResponseValue;
15294 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
15296 export function InMemorySigner_clone(orig: number): number {
15297 if(!isWasmInitialized) {
15298 throw new Error("initializeWasm() must be awaited first!");
15300 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
15301 return nativeResponseValue;
15303 // 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);
15305 export function InMemorySigner_new(funding_key: number, revocation_base_key: number, payment_key: number, delayed_payment_base_key: number, htlc_base_key: number, commitment_seed: number, channel_value_satoshis: bigint, channel_keys_id: number): number {
15306 if(!isWasmInitialized) {
15307 throw new Error("initializeWasm() must be awaited first!");
15309 const nativeResponseValue = wasm.TS_InMemorySigner_new(funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
15310 return nativeResponseValue;
15312 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15314 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
15315 if(!isWasmInitialized) {
15316 throw new Error("initializeWasm() must be awaited first!");
15318 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
15319 return nativeResponseValue;
15321 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15323 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
15324 if(!isWasmInitialized) {
15325 throw new Error("initializeWasm() must be awaited first!");
15327 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
15328 return nativeResponseValue;
15330 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15332 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
15333 if(!isWasmInitialized) {
15334 throw new Error("initializeWasm() must be awaited first!");
15336 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
15337 return nativeResponseValue;
15339 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15341 export function InMemorySigner_is_outbound(this_arg: number): boolean {
15342 if(!isWasmInitialized) {
15343 throw new Error("initializeWasm() must be awaited first!");
15345 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
15346 return nativeResponseValue;
15348 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15350 export function InMemorySigner_funding_outpoint(this_arg: number): number {
15351 if(!isWasmInitialized) {
15352 throw new Error("initializeWasm() must be awaited first!");
15354 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
15355 return nativeResponseValue;
15357 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15359 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
15360 if(!isWasmInitialized) {
15361 throw new Error("initializeWasm() must be awaited first!");
15363 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
15364 return nativeResponseValue;
15366 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15368 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
15369 if(!isWasmInitialized) {
15370 throw new Error("initializeWasm() must be awaited first!");
15372 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
15373 return nativeResponseValue;
15375 // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_counterparty_payment_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR descriptor);
15377 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
15378 if(!isWasmInitialized) {
15379 throw new Error("initializeWasm() must be awaited first!");
15381 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
15382 return nativeResponseValue;
15384 // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_dynamic_p2wsh_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR descriptor);
15386 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
15387 if(!isWasmInitialized) {
15388 throw new Error("initializeWasm() must be awaited first!");
15390 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
15391 return nativeResponseValue;
15393 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15395 export function InMemorySigner_as_BaseSign(this_arg: number): number {
15396 if(!isWasmInitialized) {
15397 throw new Error("initializeWasm() must be awaited first!");
15399 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
15400 return nativeResponseValue;
15402 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15404 export function InMemorySigner_as_Sign(this_arg: number): number {
15405 if(!isWasmInitialized) {
15406 throw new Error("initializeWasm() must be awaited first!");
15408 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
15409 return nativeResponseValue;
15411 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
15413 export function InMemorySigner_write(obj: number): number {
15414 if(!isWasmInitialized) {
15415 throw new Error("initializeWasm() must be awaited first!");
15417 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
15418 return nativeResponseValue;
15420 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
15422 export function InMemorySigner_read(ser: number): number {
15423 if(!isWasmInitialized) {
15424 throw new Error("initializeWasm() must be awaited first!");
15426 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser);
15427 return nativeResponseValue;
15429 // void KeysManager_free(struct LDKKeysManager this_obj);
15431 export function KeysManager_free(this_obj: number): void {
15432 if(!isWasmInitialized) {
15433 throw new Error("initializeWasm() must be awaited first!");
15435 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
15436 // debug statements here
15438 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
15440 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
15441 if(!isWasmInitialized) {
15442 throw new Error("initializeWasm() must be awaited first!");
15444 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
15445 return nativeResponseValue;
15447 // MUST_USE_RES struct LDKInMemorySigner KeysManager_derive_channel_keys(const struct LDKKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, const uint8_t (*params)[32]);
15449 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
15450 if(!isWasmInitialized) {
15451 throw new Error("initializeWasm() must be awaited first!");
15453 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
15454 return nativeResponseValue;
15456 // MUST_USE_RES struct LDKCResult_TransactionNoneZ KeysManager_spend_spendable_outputs(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight);
15458 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
15459 if(!isWasmInitialized) {
15460 throw new Error("initializeWasm() must be awaited first!");
15462 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
15463 return nativeResponseValue;
15465 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
15467 export function KeysManager_as_KeysInterface(this_arg: number): number {
15468 if(!isWasmInitialized) {
15469 throw new Error("initializeWasm() must be awaited first!");
15471 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
15472 return nativeResponseValue;
15474 // void ChannelManager_free(struct LDKChannelManager this_obj);
15476 export function ChannelManager_free(this_obj: number): void {
15477 if(!isWasmInitialized) {
15478 throw new Error("initializeWasm() must be awaited first!");
15480 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
15481 // debug statements here
15483 // void ChainParameters_free(struct LDKChainParameters this_obj);
15485 export function ChainParameters_free(this_obj: number): void {
15486 if(!isWasmInitialized) {
15487 throw new Error("initializeWasm() must be awaited first!");
15489 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
15490 // debug statements here
15492 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
15494 export function ChainParameters_get_network(this_ptr: number): Network {
15495 if(!isWasmInitialized) {
15496 throw new Error("initializeWasm() must be awaited first!");
15498 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
15499 return nativeResponseValue;
15501 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
15503 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
15504 if(!isWasmInitialized) {
15505 throw new Error("initializeWasm() must be awaited first!");
15507 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
15508 // debug statements here
15510 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
15512 export function ChainParameters_get_best_block(this_ptr: number): number {
15513 if(!isWasmInitialized) {
15514 throw new Error("initializeWasm() must be awaited first!");
15516 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
15517 return nativeResponseValue;
15519 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
15521 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
15522 if(!isWasmInitialized) {
15523 throw new Error("initializeWasm() must be awaited first!");
15525 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
15526 // debug statements here
15528 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
15530 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
15531 if(!isWasmInitialized) {
15532 throw new Error("initializeWasm() must be awaited first!");
15534 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
15535 return nativeResponseValue;
15537 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
15539 export function ChainParameters_clone_ptr(arg: number): number {
15540 if(!isWasmInitialized) {
15541 throw new Error("initializeWasm() must be awaited first!");
15543 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
15544 return nativeResponseValue;
15546 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
15548 export function ChainParameters_clone(orig: number): number {
15549 if(!isWasmInitialized) {
15550 throw new Error("initializeWasm() must be awaited first!");
15552 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
15553 return nativeResponseValue;
15555 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
15557 export function CounterpartyForwardingInfo_free(this_obj: number): void {
15558 if(!isWasmInitialized) {
15559 throw new Error("initializeWasm() must be awaited first!");
15561 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
15562 // debug statements here
15564 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
15566 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
15567 if(!isWasmInitialized) {
15568 throw new Error("initializeWasm() must be awaited first!");
15570 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
15571 return nativeResponseValue;
15573 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
15575 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
15576 if(!isWasmInitialized) {
15577 throw new Error("initializeWasm() must be awaited first!");
15579 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
15580 // debug statements here
15582 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
15584 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
15585 if(!isWasmInitialized) {
15586 throw new Error("initializeWasm() must be awaited first!");
15588 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
15589 return nativeResponseValue;
15591 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
15593 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
15594 if(!isWasmInitialized) {
15595 throw new Error("initializeWasm() must be awaited first!");
15597 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
15598 // debug statements here
15600 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
15602 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
15603 if(!isWasmInitialized) {
15604 throw new Error("initializeWasm() must be awaited first!");
15606 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
15607 return nativeResponseValue;
15609 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
15611 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
15612 if(!isWasmInitialized) {
15613 throw new Error("initializeWasm() must be awaited first!");
15615 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
15616 // debug statements here
15618 // 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);
15620 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
15621 if(!isWasmInitialized) {
15622 throw new Error("initializeWasm() must be awaited first!");
15624 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
15625 return nativeResponseValue;
15627 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
15629 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
15630 if(!isWasmInitialized) {
15631 throw new Error("initializeWasm() must be awaited first!");
15633 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
15634 return nativeResponseValue;
15636 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
15638 export function CounterpartyForwardingInfo_clone(orig: number): number {
15639 if(!isWasmInitialized) {
15640 throw new Error("initializeWasm() must be awaited first!");
15642 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
15643 return nativeResponseValue;
15645 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
15647 export function ChannelCounterparty_free(this_obj: number): void {
15648 if(!isWasmInitialized) {
15649 throw new Error("initializeWasm() must be awaited first!");
15651 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
15652 // debug statements here
15654 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15656 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
15657 if(!isWasmInitialized) {
15658 throw new Error("initializeWasm() must be awaited first!");
15660 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
15661 return nativeResponseValue;
15663 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
15665 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
15666 if(!isWasmInitialized) {
15667 throw new Error("initializeWasm() must be awaited first!");
15669 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
15670 // debug statements here
15672 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15674 export function ChannelCounterparty_get_features(this_ptr: number): number {
15675 if(!isWasmInitialized) {
15676 throw new Error("initializeWasm() must be awaited first!");
15678 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
15679 return nativeResponseValue;
15681 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
15683 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
15684 if(!isWasmInitialized) {
15685 throw new Error("initializeWasm() must be awaited first!");
15687 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
15688 // debug statements here
15690 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15692 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
15693 if(!isWasmInitialized) {
15694 throw new Error("initializeWasm() must be awaited first!");
15696 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
15697 return nativeResponseValue;
15699 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
15701 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
15702 if(!isWasmInitialized) {
15703 throw new Error("initializeWasm() must be awaited first!");
15705 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
15706 // debug statements here
15708 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15710 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
15711 if(!isWasmInitialized) {
15712 throw new Error("initializeWasm() must be awaited first!");
15714 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
15715 return nativeResponseValue;
15717 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
15719 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
15720 if(!isWasmInitialized) {
15721 throw new Error("initializeWasm() must be awaited first!");
15723 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
15724 // debug statements here
15726 // 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);
15728 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number): number {
15729 if(!isWasmInitialized) {
15730 throw new Error("initializeWasm() must be awaited first!");
15732 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
15733 return nativeResponseValue;
15735 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
15737 export function ChannelCounterparty_clone_ptr(arg: number): number {
15738 if(!isWasmInitialized) {
15739 throw new Error("initializeWasm() must be awaited first!");
15741 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
15742 return nativeResponseValue;
15744 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
15746 export function ChannelCounterparty_clone(orig: number): number {
15747 if(!isWasmInitialized) {
15748 throw new Error("initializeWasm() must be awaited first!");
15750 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
15751 return nativeResponseValue;
15753 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
15755 export function ChannelDetails_free(this_obj: number): void {
15756 if(!isWasmInitialized) {
15757 throw new Error("initializeWasm() must be awaited first!");
15759 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
15760 // debug statements here
15762 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
15764 export function ChannelDetails_get_channel_id(this_ptr: number): number {
15765 if(!isWasmInitialized) {
15766 throw new Error("initializeWasm() must be awaited first!");
15768 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
15769 return nativeResponseValue;
15771 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
15773 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
15774 if(!isWasmInitialized) {
15775 throw new Error("initializeWasm() must be awaited first!");
15777 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
15778 // debug statements here
15780 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15782 export function ChannelDetails_get_counterparty(this_ptr: number): number {
15783 if(!isWasmInitialized) {
15784 throw new Error("initializeWasm() must be awaited first!");
15786 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
15787 return nativeResponseValue;
15789 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
15791 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
15792 if(!isWasmInitialized) {
15793 throw new Error("initializeWasm() must be awaited first!");
15795 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
15796 // debug statements here
15798 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15800 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
15801 if(!isWasmInitialized) {
15802 throw new Error("initializeWasm() must be awaited first!");
15804 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
15805 return nativeResponseValue;
15807 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
15809 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
15810 if(!isWasmInitialized) {
15811 throw new Error("initializeWasm() must be awaited first!");
15813 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
15814 // debug statements here
15816 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15818 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
15819 if(!isWasmInitialized) {
15820 throw new Error("initializeWasm() must be awaited first!");
15822 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
15823 return nativeResponseValue;
15825 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
15827 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
15828 if(!isWasmInitialized) {
15829 throw new Error("initializeWasm() must be awaited first!");
15831 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
15832 // debug statements here
15834 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15836 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
15837 if(!isWasmInitialized) {
15838 throw new Error("initializeWasm() must be awaited first!");
15840 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
15841 return nativeResponseValue;
15843 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15845 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
15846 if(!isWasmInitialized) {
15847 throw new Error("initializeWasm() must be awaited first!");
15849 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
15850 // debug statements here
15852 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15854 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
15855 if(!isWasmInitialized) {
15856 throw new Error("initializeWasm() must be awaited first!");
15858 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
15859 return nativeResponseValue;
15861 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
15863 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
15864 if(!isWasmInitialized) {
15865 throw new Error("initializeWasm() must be awaited first!");
15867 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
15868 // debug statements here
15870 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15872 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
15873 if(!isWasmInitialized) {
15874 throw new Error("initializeWasm() must be awaited first!");
15876 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
15877 return nativeResponseValue;
15879 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15881 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
15882 if(!isWasmInitialized) {
15883 throw new Error("initializeWasm() must be awaited first!");
15885 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
15886 // debug statements here
15888 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15890 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
15891 if(!isWasmInitialized) {
15892 throw new Error("initializeWasm() must be awaited first!");
15894 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
15895 return nativeResponseValue;
15897 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15899 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
15900 if(!isWasmInitialized) {
15901 throw new Error("initializeWasm() must be awaited first!");
15903 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
15904 // debug statements here
15906 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15908 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
15909 if(!isWasmInitialized) {
15910 throw new Error("initializeWasm() must be awaited first!");
15912 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
15913 return nativeResponseValue;
15915 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15917 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
15918 if(!isWasmInitialized) {
15919 throw new Error("initializeWasm() must be awaited first!");
15921 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
15922 // debug statements here
15924 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15926 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
15927 if(!isWasmInitialized) {
15928 throw new Error("initializeWasm() must be awaited first!");
15930 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
15931 return nativeResponseValue;
15933 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15935 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
15936 if(!isWasmInitialized) {
15937 throw new Error("initializeWasm() must be awaited first!");
15939 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
15940 // debug statements here
15942 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15944 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
15945 if(!isWasmInitialized) {
15946 throw new Error("initializeWasm() must be awaited first!");
15948 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
15949 return nativeResponseValue;
15951 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
15953 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
15954 if(!isWasmInitialized) {
15955 throw new Error("initializeWasm() must be awaited first!");
15957 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
15958 // debug statements here
15960 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15962 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
15963 if(!isWasmInitialized) {
15964 throw new Error("initializeWasm() must be awaited first!");
15966 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
15967 return nativeResponseValue;
15969 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
15971 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
15972 if(!isWasmInitialized) {
15973 throw new Error("initializeWasm() must be awaited first!");
15975 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
15976 // debug statements here
15978 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15980 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
15981 if(!isWasmInitialized) {
15982 throw new Error("initializeWasm() must be awaited first!");
15984 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
15985 return nativeResponseValue;
15987 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
15989 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
15990 if(!isWasmInitialized) {
15991 throw new Error("initializeWasm() must be awaited first!");
15993 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
15994 // debug statements here
15996 // bool ChannelDetails_get_is_funding_locked(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15998 export function ChannelDetails_get_is_funding_locked(this_ptr: number): boolean {
15999 if(!isWasmInitialized) {
16000 throw new Error("initializeWasm() must be awaited first!");
16002 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_funding_locked(this_ptr);
16003 return nativeResponseValue;
16005 // void ChannelDetails_set_is_funding_locked(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
16007 export function ChannelDetails_set_is_funding_locked(this_ptr: number, val: boolean): void {
16008 if(!isWasmInitialized) {
16009 throw new Error("initializeWasm() must be awaited first!");
16011 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_funding_locked(this_ptr, val);
16012 // debug statements here
16014 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
16016 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
16017 if(!isWasmInitialized) {
16018 throw new Error("initializeWasm() must be awaited first!");
16020 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
16021 return nativeResponseValue;
16023 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
16025 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
16026 if(!isWasmInitialized) {
16027 throw new Error("initializeWasm() must be awaited first!");
16029 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
16030 // debug statements here
16032 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
16034 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
16035 if(!isWasmInitialized) {
16036 throw new Error("initializeWasm() must be awaited first!");
16038 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
16039 return nativeResponseValue;
16041 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
16043 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
16044 if(!isWasmInitialized) {
16045 throw new Error("initializeWasm() must be awaited first!");
16047 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
16048 // debug statements here
16050 // 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 balance_msat_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);
16052 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: number, funding_txo_arg: number, short_channel_id_arg: number, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: number, user_channel_id_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_funding_locked_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean): number {
16053 if(!isWasmInitialized) {
16054 throw new Error("initializeWasm() must be awaited first!");
16056 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, short_channel_id_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_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);
16057 return nativeResponseValue;
16059 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
16061 export function ChannelDetails_clone_ptr(arg: number): number {
16062 if(!isWasmInitialized) {
16063 throw new Error("initializeWasm() must be awaited first!");
16065 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
16066 return nativeResponseValue;
16068 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
16070 export function ChannelDetails_clone(orig: number): number {
16071 if(!isWasmInitialized) {
16072 throw new Error("initializeWasm() must be awaited first!");
16074 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
16075 return nativeResponseValue;
16077 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
16079 export function PaymentSendFailure_free(this_ptr: number): void {
16080 if(!isWasmInitialized) {
16081 throw new Error("initializeWasm() must be awaited first!");
16083 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
16084 // debug statements here
16086 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
16088 export function PaymentSendFailure_clone_ptr(arg: number): number {
16089 if(!isWasmInitialized) {
16090 throw new Error("initializeWasm() must be awaited first!");
16092 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
16093 return nativeResponseValue;
16095 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
16097 export function PaymentSendFailure_clone(orig: number): number {
16098 if(!isWasmInitialized) {
16099 throw new Error("initializeWasm() must be awaited first!");
16101 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
16102 return nativeResponseValue;
16104 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
16106 export function PaymentSendFailure_parameter_error(a: number): number {
16107 if(!isWasmInitialized) {
16108 throw new Error("initializeWasm() must be awaited first!");
16110 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
16111 return nativeResponseValue;
16113 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
16115 export function PaymentSendFailure_path_parameter_error(a: number): number {
16116 if(!isWasmInitialized) {
16117 throw new Error("initializeWasm() must be awaited first!");
16119 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
16120 return nativeResponseValue;
16122 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
16124 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
16125 if(!isWasmInitialized) {
16126 throw new Error("initializeWasm() must be awaited first!");
16128 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
16129 return nativeResponseValue;
16131 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
16133 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
16134 if(!isWasmInitialized) {
16135 throw new Error("initializeWasm() must be awaited first!");
16137 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
16138 return nativeResponseValue;
16140 // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params);
16142 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
16143 if(!isWasmInitialized) {
16144 throw new Error("initializeWasm() must be awaited first!");
16146 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
16147 return nativeResponseValue;
16149 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
16151 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
16152 if(!isWasmInitialized) {
16153 throw new Error("initializeWasm() must be awaited first!");
16155 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
16156 return nativeResponseValue;
16158 // MUST_USE_RES struct LDKCResult__u832APIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_channel_id, struct LDKUserConfig override_config);
16160 export function ChannelManager_create_channel(this_arg: number, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: bigint, override_config: number): number {
16161 if(!isWasmInitialized) {
16162 throw new Error("initializeWasm() must be awaited first!");
16164 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
16165 return nativeResponseValue;
16167 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
16169 export function ChannelManager_list_channels(this_arg: number): number {
16170 if(!isWasmInitialized) {
16171 throw new Error("initializeWasm() must be awaited first!");
16173 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
16174 return nativeResponseValue;
16176 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
16178 export function ChannelManager_list_usable_channels(this_arg: number): number {
16179 if(!isWasmInitialized) {
16180 throw new Error("initializeWasm() must be awaited first!");
16182 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
16183 return nativeResponseValue;
16185 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
16187 export function ChannelManager_close_channel(this_arg: number, channel_id: number): number {
16188 if(!isWasmInitialized) {
16189 throw new Error("initializeWasm() must be awaited first!");
16191 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id);
16192 return nativeResponseValue;
16194 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_target_feerate(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], uint32_t target_feerate_sats_per_1000_weight);
16196 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, target_feerate_sats_per_1000_weight: number): number {
16197 if(!isWasmInitialized) {
16198 throw new Error("initializeWasm() must be awaited first!");
16200 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, target_feerate_sats_per_1000_weight);
16201 return nativeResponseValue;
16203 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
16205 export function ChannelManager_force_close_channel(this_arg: number, channel_id: number): number {
16206 if(!isWasmInitialized) {
16207 throw new Error("initializeWasm() must be awaited first!");
16209 const nativeResponseValue = wasm.TS_ChannelManager_force_close_channel(this_arg, channel_id);
16210 return nativeResponseValue;
16212 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
16214 export function ChannelManager_force_close_all_channels(this_arg: number): void {
16215 if(!isWasmInitialized) {
16216 throw new Error("initializeWasm() must be awaited first!");
16218 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
16219 // debug statements here
16221 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
16223 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
16224 if(!isWasmInitialized) {
16225 throw new Error("initializeWasm() must be awaited first!");
16227 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
16228 return nativeResponseValue;
16230 // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_retry_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id);
16232 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
16233 if(!isWasmInitialized) {
16234 throw new Error("initializeWasm() must be awaited first!");
16236 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
16237 return nativeResponseValue;
16239 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
16241 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
16242 if(!isWasmInitialized) {
16243 throw new Error("initializeWasm() must be awaited first!");
16245 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
16246 // debug statements here
16248 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
16250 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
16251 if(!isWasmInitialized) {
16252 throw new Error("initializeWasm() must be awaited first!");
16254 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
16255 return nativeResponseValue;
16257 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKTransaction funding_transaction);
16259 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, funding_transaction: number): number {
16260 if(!isWasmInitialized) {
16261 throw new Error("initializeWasm() must be awaited first!");
16263 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, funding_transaction);
16264 return nativeResponseValue;
16266 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
16268 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
16269 if(!isWasmInitialized) {
16270 throw new Error("initializeWasm() must be awaited first!");
16272 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
16273 // debug statements here
16275 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
16277 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
16278 if(!isWasmInitialized) {
16279 throw new Error("initializeWasm() must be awaited first!");
16281 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
16282 // debug statements here
16284 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
16286 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
16287 if(!isWasmInitialized) {
16288 throw new Error("initializeWasm() must be awaited first!");
16290 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
16291 // debug statements here
16293 // MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
16295 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): boolean {
16296 if(!isWasmInitialized) {
16297 throw new Error("initializeWasm() must be awaited first!");
16299 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
16300 return nativeResponseValue;
16302 // MUST_USE_RES bool ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
16304 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): boolean {
16305 if(!isWasmInitialized) {
16306 throw new Error("initializeWasm() must be awaited first!");
16308 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
16309 return nativeResponseValue;
16311 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
16313 export function ChannelManager_get_our_node_id(this_arg: number): number {
16314 if(!isWasmInitialized) {
16315 throw new Error("initializeWasm() must be awaited first!");
16317 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
16318 return nativeResponseValue;
16320 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ ChannelManager_create_inbound_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
16322 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
16323 if(!isWasmInitialized) {
16324 throw new Error("initializeWasm() must be awaited first!");
16326 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
16327 return nativeResponseValue;
16329 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ ChannelManager_create_inbound_payment_legacy(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
16331 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
16332 if(!isWasmInitialized) {
16333 throw new Error("initializeWasm() must be awaited first!");
16335 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
16336 return nativeResponseValue;
16338 // MUST_USE_RES struct LDKCResult_PaymentSecretNoneZ ChannelManager_create_inbound_payment_for_hash(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
16340 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
16341 if(!isWasmInitialized) {
16342 throw new Error("initializeWasm() must be awaited first!");
16344 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
16345 return nativeResponseValue;
16347 // MUST_USE_RES struct LDKCResult_PaymentSecretAPIErrorZ ChannelManager_create_inbound_payment_for_hash_legacy(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs);
16349 export function ChannelManager_create_inbound_payment_for_hash_legacy(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
16350 if(!isWasmInitialized) {
16351 throw new Error("initializeWasm() must be awaited first!");
16353 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
16354 return nativeResponseValue;
16356 // MUST_USE_RES struct LDKCResult_PaymentPreimageAPIErrorZ ChannelManager_get_payment_preimage(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
16358 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
16359 if(!isWasmInitialized) {
16360 throw new Error("initializeWasm() must be awaited first!");
16362 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
16363 return nativeResponseValue;
16365 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
16367 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
16368 if(!isWasmInitialized) {
16369 throw new Error("initializeWasm() must be awaited first!");
16371 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
16372 return nativeResponseValue;
16374 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
16376 export function ChannelManager_as_EventsProvider(this_arg: number): number {
16377 if(!isWasmInitialized) {
16378 throw new Error("initializeWasm() must be awaited first!");
16380 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
16381 return nativeResponseValue;
16383 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
16385 export function ChannelManager_as_Listen(this_arg: number): number {
16386 if(!isWasmInitialized) {
16387 throw new Error("initializeWasm() must be awaited first!");
16389 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
16390 return nativeResponseValue;
16392 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
16394 export function ChannelManager_as_Confirm(this_arg: number): number {
16395 if(!isWasmInitialized) {
16396 throw new Error("initializeWasm() must be awaited first!");
16398 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
16399 return nativeResponseValue;
16401 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
16403 export function ChannelManager_await_persistable_update(this_arg: number): void {
16404 if(!isWasmInitialized) {
16405 throw new Error("initializeWasm() must be awaited first!");
16407 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
16408 // debug statements here
16410 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
16412 export function ChannelManager_current_best_block(this_arg: number): number {
16413 if(!isWasmInitialized) {
16414 throw new Error("initializeWasm() must be awaited first!");
16416 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
16417 return nativeResponseValue;
16419 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
16421 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
16422 if(!isWasmInitialized) {
16423 throw new Error("initializeWasm() must be awaited first!");
16425 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
16426 return nativeResponseValue;
16428 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
16430 export function ChannelManager_write(obj: number): number {
16431 if(!isWasmInitialized) {
16432 throw new Error("initializeWasm() must be awaited first!");
16434 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
16435 return nativeResponseValue;
16437 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
16439 export function ChannelManagerReadArgs_free(this_obj: number): void {
16440 if(!isWasmInitialized) {
16441 throw new Error("initializeWasm() must be awaited first!");
16443 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
16444 // debug statements here
16446 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16448 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
16449 if(!isWasmInitialized) {
16450 throw new Error("initializeWasm() must be awaited first!");
16452 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
16453 return nativeResponseValue;
16455 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
16457 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
16458 if(!isWasmInitialized) {
16459 throw new Error("initializeWasm() must be awaited first!");
16461 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
16462 // debug statements here
16464 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16466 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
16467 if(!isWasmInitialized) {
16468 throw new Error("initializeWasm() must be awaited first!");
16470 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
16471 return nativeResponseValue;
16473 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
16475 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
16476 if(!isWasmInitialized) {
16477 throw new Error("initializeWasm() must be awaited first!");
16479 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
16480 // debug statements here
16482 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16484 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
16485 if(!isWasmInitialized) {
16486 throw new Error("initializeWasm() must be awaited first!");
16488 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
16489 return nativeResponseValue;
16491 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
16493 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
16494 if(!isWasmInitialized) {
16495 throw new Error("initializeWasm() must be awaited first!");
16497 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
16498 // debug statements here
16500 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16502 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
16503 if(!isWasmInitialized) {
16504 throw new Error("initializeWasm() must be awaited first!");
16506 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
16507 return nativeResponseValue;
16509 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
16511 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
16512 if(!isWasmInitialized) {
16513 throw new Error("initializeWasm() must be awaited first!");
16515 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
16516 // debug statements here
16518 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16520 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
16521 if(!isWasmInitialized) {
16522 throw new Error("initializeWasm() must be awaited first!");
16524 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
16525 return nativeResponseValue;
16527 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
16529 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
16530 if(!isWasmInitialized) {
16531 throw new Error("initializeWasm() must be awaited first!");
16533 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
16534 // debug statements here
16536 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16538 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
16539 if(!isWasmInitialized) {
16540 throw new Error("initializeWasm() must be awaited first!");
16542 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
16543 return nativeResponseValue;
16545 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
16547 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
16548 if(!isWasmInitialized) {
16549 throw new Error("initializeWasm() must be awaited first!");
16551 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
16552 // debug statements here
16554 // MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKKeysInterface keys_manager, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
16556 export function ChannelManagerReadArgs_new(keys_manager: number, fee_estimator: number, chain_monitor: number, tx_broadcaster: number, logger: number, default_config: number, channel_monitors: number): number {
16557 if(!isWasmInitialized) {
16558 throw new Error("initializeWasm() must be awaited first!");
16560 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
16561 return nativeResponseValue;
16563 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
16565 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
16566 if(!isWasmInitialized) {
16567 throw new Error("initializeWasm() must be awaited first!");
16569 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
16570 return nativeResponseValue;
16572 // void DecodeError_free(struct LDKDecodeError this_obj);
16574 export function DecodeError_free(this_obj: number): void {
16575 if(!isWasmInitialized) {
16576 throw new Error("initializeWasm() must be awaited first!");
16578 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
16579 // debug statements here
16581 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
16583 export function DecodeError_clone_ptr(arg: number): number {
16584 if(!isWasmInitialized) {
16585 throw new Error("initializeWasm() must be awaited first!");
16587 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
16588 return nativeResponseValue;
16590 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
16592 export function DecodeError_clone(orig: number): number {
16593 if(!isWasmInitialized) {
16594 throw new Error("initializeWasm() must be awaited first!");
16596 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
16597 return nativeResponseValue;
16599 // void Init_free(struct LDKInit this_obj);
16601 export function Init_free(this_obj: number): void {
16602 if(!isWasmInitialized) {
16603 throw new Error("initializeWasm() must be awaited first!");
16605 const nativeResponseValue = wasm.TS_Init_free(this_obj);
16606 // debug statements here
16608 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
16610 export function Init_get_features(this_ptr: number): number {
16611 if(!isWasmInitialized) {
16612 throw new Error("initializeWasm() must be awaited first!");
16614 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
16615 return nativeResponseValue;
16617 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
16619 export function Init_set_features(this_ptr: number, val: number): void {
16620 if(!isWasmInitialized) {
16621 throw new Error("initializeWasm() must be awaited first!");
16623 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
16624 // debug statements here
16626 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
16628 export function Init_new(features_arg: number): number {
16629 if(!isWasmInitialized) {
16630 throw new Error("initializeWasm() must be awaited first!");
16632 const nativeResponseValue = wasm.TS_Init_new(features_arg);
16633 return nativeResponseValue;
16635 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
16637 export function Init_clone_ptr(arg: number): number {
16638 if(!isWasmInitialized) {
16639 throw new Error("initializeWasm() must be awaited first!");
16641 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
16642 return nativeResponseValue;
16644 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
16646 export function Init_clone(orig: number): number {
16647 if(!isWasmInitialized) {
16648 throw new Error("initializeWasm() must be awaited first!");
16650 const nativeResponseValue = wasm.TS_Init_clone(orig);
16651 return nativeResponseValue;
16653 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
16655 export function ErrorMessage_free(this_obj: number): void {
16656 if(!isWasmInitialized) {
16657 throw new Error("initializeWasm() must be awaited first!");
16659 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
16660 // debug statements here
16662 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
16664 export function ErrorMessage_get_channel_id(this_ptr: number): number {
16665 if(!isWasmInitialized) {
16666 throw new Error("initializeWasm() must be awaited first!");
16668 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
16669 return nativeResponseValue;
16671 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16673 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
16674 if(!isWasmInitialized) {
16675 throw new Error("initializeWasm() must be awaited first!");
16677 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
16678 // debug statements here
16680 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
16682 export function ErrorMessage_get_data(this_ptr: number): number {
16683 if(!isWasmInitialized) {
16684 throw new Error("initializeWasm() must be awaited first!");
16686 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
16687 return nativeResponseValue;
16689 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
16691 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
16692 if(!isWasmInitialized) {
16693 throw new Error("initializeWasm() must be awaited first!");
16695 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
16696 // debug statements here
16698 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
16700 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
16701 if(!isWasmInitialized) {
16702 throw new Error("initializeWasm() must be awaited first!");
16704 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
16705 return nativeResponseValue;
16707 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
16709 export function ErrorMessage_clone_ptr(arg: number): number {
16710 if(!isWasmInitialized) {
16711 throw new Error("initializeWasm() must be awaited first!");
16713 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
16714 return nativeResponseValue;
16716 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
16718 export function ErrorMessage_clone(orig: number): number {
16719 if(!isWasmInitialized) {
16720 throw new Error("initializeWasm() must be awaited first!");
16722 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
16723 return nativeResponseValue;
16725 // void Ping_free(struct LDKPing this_obj);
16727 export function Ping_free(this_obj: number): void {
16728 if(!isWasmInitialized) {
16729 throw new Error("initializeWasm() must be awaited first!");
16731 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
16732 // debug statements here
16734 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
16736 export function Ping_get_ponglen(this_ptr: number): number {
16737 if(!isWasmInitialized) {
16738 throw new Error("initializeWasm() must be awaited first!");
16740 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
16741 return nativeResponseValue;
16743 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
16745 export function Ping_set_ponglen(this_ptr: number, val: number): void {
16746 if(!isWasmInitialized) {
16747 throw new Error("initializeWasm() must be awaited first!");
16749 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
16750 // debug statements here
16752 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
16754 export function Ping_get_byteslen(this_ptr: number): number {
16755 if(!isWasmInitialized) {
16756 throw new Error("initializeWasm() must be awaited first!");
16758 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
16759 return nativeResponseValue;
16761 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
16763 export function Ping_set_byteslen(this_ptr: number, val: number): void {
16764 if(!isWasmInitialized) {
16765 throw new Error("initializeWasm() must be awaited first!");
16767 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
16768 // debug statements here
16770 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
16772 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
16773 if(!isWasmInitialized) {
16774 throw new Error("initializeWasm() must be awaited first!");
16776 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
16777 return nativeResponseValue;
16779 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
16781 export function Ping_clone_ptr(arg: number): number {
16782 if(!isWasmInitialized) {
16783 throw new Error("initializeWasm() must be awaited first!");
16785 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
16786 return nativeResponseValue;
16788 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
16790 export function Ping_clone(orig: number): number {
16791 if(!isWasmInitialized) {
16792 throw new Error("initializeWasm() must be awaited first!");
16794 const nativeResponseValue = wasm.TS_Ping_clone(orig);
16795 return nativeResponseValue;
16797 // void Pong_free(struct LDKPong this_obj);
16799 export function Pong_free(this_obj: number): void {
16800 if(!isWasmInitialized) {
16801 throw new Error("initializeWasm() must be awaited first!");
16803 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
16804 // debug statements here
16806 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
16808 export function Pong_get_byteslen(this_ptr: number): number {
16809 if(!isWasmInitialized) {
16810 throw new Error("initializeWasm() must be awaited first!");
16812 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
16813 return nativeResponseValue;
16815 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
16817 export function Pong_set_byteslen(this_ptr: number, val: number): void {
16818 if(!isWasmInitialized) {
16819 throw new Error("initializeWasm() must be awaited first!");
16821 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
16822 // debug statements here
16824 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
16826 export function Pong_new(byteslen_arg: number): number {
16827 if(!isWasmInitialized) {
16828 throw new Error("initializeWasm() must be awaited first!");
16830 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
16831 return nativeResponseValue;
16833 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
16835 export function Pong_clone_ptr(arg: number): number {
16836 if(!isWasmInitialized) {
16837 throw new Error("initializeWasm() must be awaited first!");
16839 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
16840 return nativeResponseValue;
16842 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
16844 export function Pong_clone(orig: number): number {
16845 if(!isWasmInitialized) {
16846 throw new Error("initializeWasm() must be awaited first!");
16848 const nativeResponseValue = wasm.TS_Pong_clone(orig);
16849 return nativeResponseValue;
16851 // void OpenChannel_free(struct LDKOpenChannel this_obj);
16853 export function OpenChannel_free(this_obj: number): void {
16854 if(!isWasmInitialized) {
16855 throw new Error("initializeWasm() must be awaited first!");
16857 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
16858 // debug statements here
16860 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
16862 export function OpenChannel_get_chain_hash(this_ptr: number): number {
16863 if(!isWasmInitialized) {
16864 throw new Error("initializeWasm() must be awaited first!");
16866 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
16867 return nativeResponseValue;
16869 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16871 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
16872 if(!isWasmInitialized) {
16873 throw new Error("initializeWasm() must be awaited first!");
16875 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
16876 // debug statements here
16878 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
16880 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
16881 if(!isWasmInitialized) {
16882 throw new Error("initializeWasm() must be awaited first!");
16884 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
16885 return nativeResponseValue;
16887 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16889 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
16890 if(!isWasmInitialized) {
16891 throw new Error("initializeWasm() must be awaited first!");
16893 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
16894 // debug statements here
16896 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16898 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
16899 if(!isWasmInitialized) {
16900 throw new Error("initializeWasm() must be awaited first!");
16902 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
16903 return nativeResponseValue;
16905 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16907 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
16908 if(!isWasmInitialized) {
16909 throw new Error("initializeWasm() must be awaited first!");
16911 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
16912 // debug statements here
16914 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16916 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
16917 if(!isWasmInitialized) {
16918 throw new Error("initializeWasm() must be awaited first!");
16920 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
16921 return nativeResponseValue;
16923 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16925 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
16926 if(!isWasmInitialized) {
16927 throw new Error("initializeWasm() must be awaited first!");
16929 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
16930 // debug statements here
16932 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16934 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
16935 if(!isWasmInitialized) {
16936 throw new Error("initializeWasm() must be awaited first!");
16938 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
16939 return nativeResponseValue;
16941 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16943 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
16944 if(!isWasmInitialized) {
16945 throw new Error("initializeWasm() must be awaited first!");
16947 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
16948 // debug statements here
16950 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16952 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16953 if(!isWasmInitialized) {
16954 throw new Error("initializeWasm() must be awaited first!");
16956 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
16957 return nativeResponseValue;
16959 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16961 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16962 if(!isWasmInitialized) {
16963 throw new Error("initializeWasm() must be awaited first!");
16965 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
16966 // debug statements here
16968 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16970 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
16971 if(!isWasmInitialized) {
16972 throw new Error("initializeWasm() must be awaited first!");
16974 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
16975 return nativeResponseValue;
16977 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16979 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16980 if(!isWasmInitialized) {
16981 throw new Error("initializeWasm() must be awaited first!");
16983 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
16984 // debug statements here
16986 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16988 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
16989 if(!isWasmInitialized) {
16990 throw new Error("initializeWasm() must be awaited first!");
16992 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
16993 return nativeResponseValue;
16995 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16997 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16998 if(!isWasmInitialized) {
16999 throw new Error("initializeWasm() must be awaited first!");
17001 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
17002 // debug statements here
17004 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17006 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
17007 if(!isWasmInitialized) {
17008 throw new Error("initializeWasm() must be awaited first!");
17010 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
17011 return nativeResponseValue;
17013 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
17015 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
17016 if(!isWasmInitialized) {
17017 throw new Error("initializeWasm() must be awaited first!");
17019 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
17020 // debug statements here
17022 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17024 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
17025 if(!isWasmInitialized) {
17026 throw new Error("initializeWasm() must be awaited first!");
17028 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
17029 return nativeResponseValue;
17031 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
17033 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
17034 if(!isWasmInitialized) {
17035 throw new Error("initializeWasm() must be awaited first!");
17037 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
17038 // debug statements here
17040 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17042 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
17043 if(!isWasmInitialized) {
17044 throw new Error("initializeWasm() must be awaited first!");
17046 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
17047 return nativeResponseValue;
17049 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
17051 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
17052 if(!isWasmInitialized) {
17053 throw new Error("initializeWasm() must be awaited first!");
17055 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
17056 // debug statements here
17058 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17060 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
17061 if(!isWasmInitialized) {
17062 throw new Error("initializeWasm() must be awaited first!");
17064 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
17065 return nativeResponseValue;
17067 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17069 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
17070 if(!isWasmInitialized) {
17071 throw new Error("initializeWasm() must be awaited first!");
17073 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
17074 // debug statements here
17076 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17078 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
17079 if(!isWasmInitialized) {
17080 throw new Error("initializeWasm() must be awaited first!");
17082 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
17083 return nativeResponseValue;
17085 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17087 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
17088 if(!isWasmInitialized) {
17089 throw new Error("initializeWasm() must be awaited first!");
17091 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
17092 // debug statements here
17094 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17096 export function OpenChannel_get_payment_point(this_ptr: number): number {
17097 if(!isWasmInitialized) {
17098 throw new Error("initializeWasm() must be awaited first!");
17100 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
17101 return nativeResponseValue;
17103 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17105 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
17106 if(!isWasmInitialized) {
17107 throw new Error("initializeWasm() must be awaited first!");
17109 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
17110 // debug statements here
17112 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17114 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
17115 if(!isWasmInitialized) {
17116 throw new Error("initializeWasm() must be awaited first!");
17118 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
17119 return nativeResponseValue;
17121 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17123 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
17124 if(!isWasmInitialized) {
17125 throw new Error("initializeWasm() must be awaited first!");
17127 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
17128 // debug statements here
17130 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17132 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
17133 if(!isWasmInitialized) {
17134 throw new Error("initializeWasm() must be awaited first!");
17136 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
17137 return nativeResponseValue;
17139 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17141 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
17142 if(!isWasmInitialized) {
17143 throw new Error("initializeWasm() must be awaited first!");
17145 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
17146 // debug statements here
17148 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17150 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
17151 if(!isWasmInitialized) {
17152 throw new Error("initializeWasm() must be awaited first!");
17154 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
17155 return nativeResponseValue;
17157 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17159 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
17160 if(!isWasmInitialized) {
17161 throw new Error("initializeWasm() must be awaited first!");
17163 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
17164 // debug statements here
17166 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17168 export function OpenChannel_get_channel_flags(this_ptr: number): number {
17169 if(!isWasmInitialized) {
17170 throw new Error("initializeWasm() must be awaited first!");
17172 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
17173 return nativeResponseValue;
17175 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
17177 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
17178 if(!isWasmInitialized) {
17179 throw new Error("initializeWasm() must be awaited first!");
17181 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
17182 // debug statements here
17184 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17186 export function OpenChannel_get_channel_type(this_ptr: number): number {
17187 if(!isWasmInitialized) {
17188 throw new Error("initializeWasm() must be awaited first!");
17190 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
17191 return nativeResponseValue;
17193 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
17195 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
17196 if(!isWasmInitialized) {
17197 throw new Error("initializeWasm() must be awaited first!");
17199 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
17200 // debug statements here
17202 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
17204 export function OpenChannel_clone_ptr(arg: number): number {
17205 if(!isWasmInitialized) {
17206 throw new Error("initializeWasm() must be awaited first!");
17208 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
17209 return nativeResponseValue;
17211 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
17213 export function OpenChannel_clone(orig: number): number {
17214 if(!isWasmInitialized) {
17215 throw new Error("initializeWasm() must be awaited first!");
17217 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
17218 return nativeResponseValue;
17220 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
17222 export function AcceptChannel_free(this_obj: number): void {
17223 if(!isWasmInitialized) {
17224 throw new Error("initializeWasm() must be awaited first!");
17226 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
17227 // debug statements here
17229 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
17231 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
17232 if(!isWasmInitialized) {
17233 throw new Error("initializeWasm() must be awaited first!");
17235 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
17236 return nativeResponseValue;
17238 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17240 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
17241 if(!isWasmInitialized) {
17242 throw new Error("initializeWasm() must be awaited first!");
17244 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
17245 // debug statements here
17247 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17249 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
17250 if(!isWasmInitialized) {
17251 throw new Error("initializeWasm() must be awaited first!");
17253 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
17254 return nativeResponseValue;
17256 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17258 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
17259 if(!isWasmInitialized) {
17260 throw new Error("initializeWasm() must be awaited first!");
17262 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
17263 // debug statements here
17265 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17267 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
17268 if(!isWasmInitialized) {
17269 throw new Error("initializeWasm() must be awaited first!");
17271 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
17272 return nativeResponseValue;
17274 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17276 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
17277 if(!isWasmInitialized) {
17278 throw new Error("initializeWasm() must be awaited first!");
17280 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
17281 // debug statements here
17283 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17285 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
17286 if(!isWasmInitialized) {
17287 throw new Error("initializeWasm() must be awaited first!");
17289 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
17290 return nativeResponseValue;
17292 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17294 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
17295 if(!isWasmInitialized) {
17296 throw new Error("initializeWasm() must be awaited first!");
17298 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
17299 // debug statements here
17301 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17303 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
17304 if(!isWasmInitialized) {
17305 throw new Error("initializeWasm() must be awaited first!");
17307 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
17308 return nativeResponseValue;
17310 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17312 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
17313 if(!isWasmInitialized) {
17314 throw new Error("initializeWasm() must be awaited first!");
17316 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
17317 // debug statements here
17319 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17321 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
17322 if(!isWasmInitialized) {
17323 throw new Error("initializeWasm() must be awaited first!");
17325 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
17326 return nativeResponseValue;
17328 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
17330 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
17331 if(!isWasmInitialized) {
17332 throw new Error("initializeWasm() must be awaited first!");
17334 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
17335 // debug statements here
17337 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17339 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
17340 if(!isWasmInitialized) {
17341 throw new Error("initializeWasm() must be awaited first!");
17343 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
17344 return nativeResponseValue;
17346 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
17348 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
17349 if(!isWasmInitialized) {
17350 throw new Error("initializeWasm() must be awaited first!");
17352 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
17353 // debug statements here
17355 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17357 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
17358 if(!isWasmInitialized) {
17359 throw new Error("initializeWasm() must be awaited first!");
17361 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
17362 return nativeResponseValue;
17364 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
17366 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
17367 if(!isWasmInitialized) {
17368 throw new Error("initializeWasm() must be awaited first!");
17370 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
17371 // debug statements here
17373 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17375 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
17376 if(!isWasmInitialized) {
17377 throw new Error("initializeWasm() must be awaited first!");
17379 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
17380 return nativeResponseValue;
17382 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17384 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
17385 if(!isWasmInitialized) {
17386 throw new Error("initializeWasm() must be awaited first!");
17388 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
17389 // debug statements here
17391 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17393 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
17394 if(!isWasmInitialized) {
17395 throw new Error("initializeWasm() must be awaited first!");
17397 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
17398 return nativeResponseValue;
17400 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17402 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
17403 if(!isWasmInitialized) {
17404 throw new Error("initializeWasm() must be awaited first!");
17406 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
17407 // debug statements here
17409 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17411 export function AcceptChannel_get_payment_point(this_ptr: number): number {
17412 if(!isWasmInitialized) {
17413 throw new Error("initializeWasm() must be awaited first!");
17415 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
17416 return nativeResponseValue;
17418 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17420 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
17421 if(!isWasmInitialized) {
17422 throw new Error("initializeWasm() must be awaited first!");
17424 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
17425 // debug statements here
17427 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17429 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
17430 if(!isWasmInitialized) {
17431 throw new Error("initializeWasm() must be awaited first!");
17433 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
17434 return nativeResponseValue;
17436 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17438 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
17439 if(!isWasmInitialized) {
17440 throw new Error("initializeWasm() must be awaited first!");
17442 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
17443 // debug statements here
17445 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17447 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
17448 if(!isWasmInitialized) {
17449 throw new Error("initializeWasm() must be awaited first!");
17451 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
17452 return nativeResponseValue;
17454 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17456 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
17457 if(!isWasmInitialized) {
17458 throw new Error("initializeWasm() must be awaited first!");
17460 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
17461 // debug statements here
17463 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17465 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
17466 if(!isWasmInitialized) {
17467 throw new Error("initializeWasm() must be awaited first!");
17469 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
17470 return nativeResponseValue;
17472 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17474 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
17475 if(!isWasmInitialized) {
17476 throw new Error("initializeWasm() must be awaited first!");
17478 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
17479 // debug statements here
17481 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
17483 export function AcceptChannel_clone_ptr(arg: number): number {
17484 if(!isWasmInitialized) {
17485 throw new Error("initializeWasm() must be awaited first!");
17487 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
17488 return nativeResponseValue;
17490 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
17492 export function AcceptChannel_clone(orig: number): number {
17493 if(!isWasmInitialized) {
17494 throw new Error("initializeWasm() must be awaited first!");
17496 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
17497 return nativeResponseValue;
17499 // void FundingCreated_free(struct LDKFundingCreated this_obj);
17501 export function FundingCreated_free(this_obj: number): void {
17502 if(!isWasmInitialized) {
17503 throw new Error("initializeWasm() must be awaited first!");
17505 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
17506 // debug statements here
17508 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
17510 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
17511 if(!isWasmInitialized) {
17512 throw new Error("initializeWasm() must be awaited first!");
17514 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
17515 return nativeResponseValue;
17517 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17519 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
17520 if(!isWasmInitialized) {
17521 throw new Error("initializeWasm() must be awaited first!");
17523 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
17524 // debug statements here
17526 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
17528 export function FundingCreated_get_funding_txid(this_ptr: number): number {
17529 if(!isWasmInitialized) {
17530 throw new Error("initializeWasm() must be awaited first!");
17532 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
17533 return nativeResponseValue;
17535 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17537 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
17538 if(!isWasmInitialized) {
17539 throw new Error("initializeWasm() must be awaited first!");
17541 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
17542 // debug statements here
17544 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
17546 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
17547 if(!isWasmInitialized) {
17548 throw new Error("initializeWasm() must be awaited first!");
17550 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
17551 return nativeResponseValue;
17553 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
17555 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
17556 if(!isWasmInitialized) {
17557 throw new Error("initializeWasm() must be awaited first!");
17559 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
17560 // debug statements here
17562 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
17564 export function FundingCreated_get_signature(this_ptr: number): number {
17565 if(!isWasmInitialized) {
17566 throw new Error("initializeWasm() must be awaited first!");
17568 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
17569 return nativeResponseValue;
17571 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
17573 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
17574 if(!isWasmInitialized) {
17575 throw new Error("initializeWasm() must be awaited first!");
17577 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
17578 // debug statements here
17580 // 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);
17582 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
17583 if(!isWasmInitialized) {
17584 throw new Error("initializeWasm() must be awaited first!");
17586 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
17587 return nativeResponseValue;
17589 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
17591 export function FundingCreated_clone_ptr(arg: number): number {
17592 if(!isWasmInitialized) {
17593 throw new Error("initializeWasm() must be awaited first!");
17595 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
17596 return nativeResponseValue;
17598 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
17600 export function FundingCreated_clone(orig: number): number {
17601 if(!isWasmInitialized) {
17602 throw new Error("initializeWasm() must be awaited first!");
17604 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
17605 return nativeResponseValue;
17607 // void FundingSigned_free(struct LDKFundingSigned this_obj);
17609 export function FundingSigned_free(this_obj: number): void {
17610 if(!isWasmInitialized) {
17611 throw new Error("initializeWasm() must be awaited first!");
17613 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
17614 // debug statements here
17616 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
17618 export function FundingSigned_get_channel_id(this_ptr: number): number {
17619 if(!isWasmInitialized) {
17620 throw new Error("initializeWasm() must be awaited first!");
17622 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
17623 return nativeResponseValue;
17625 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17627 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
17628 if(!isWasmInitialized) {
17629 throw new Error("initializeWasm() must be awaited first!");
17631 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
17632 // debug statements here
17634 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
17636 export function FundingSigned_get_signature(this_ptr: number): number {
17637 if(!isWasmInitialized) {
17638 throw new Error("initializeWasm() must be awaited first!");
17640 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
17641 return nativeResponseValue;
17643 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
17645 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
17646 if(!isWasmInitialized) {
17647 throw new Error("initializeWasm() must be awaited first!");
17649 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
17650 // debug statements here
17652 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
17654 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
17655 if(!isWasmInitialized) {
17656 throw new Error("initializeWasm() must be awaited first!");
17658 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
17659 return nativeResponseValue;
17661 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
17663 export function FundingSigned_clone_ptr(arg: number): number {
17664 if(!isWasmInitialized) {
17665 throw new Error("initializeWasm() must be awaited first!");
17667 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
17668 return nativeResponseValue;
17670 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
17672 export function FundingSigned_clone(orig: number): number {
17673 if(!isWasmInitialized) {
17674 throw new Error("initializeWasm() must be awaited first!");
17676 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
17677 return nativeResponseValue;
17679 // void FundingLocked_free(struct LDKFundingLocked this_obj);
17681 export function FundingLocked_free(this_obj: number): void {
17682 if(!isWasmInitialized) {
17683 throw new Error("initializeWasm() must be awaited first!");
17685 const nativeResponseValue = wasm.TS_FundingLocked_free(this_obj);
17686 // debug statements here
17688 // const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
17690 export function FundingLocked_get_channel_id(this_ptr: number): number {
17691 if(!isWasmInitialized) {
17692 throw new Error("initializeWasm() must be awaited first!");
17694 const nativeResponseValue = wasm.TS_FundingLocked_get_channel_id(this_ptr);
17695 return nativeResponseValue;
17697 // void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17699 export function FundingLocked_set_channel_id(this_ptr: number, val: number): void {
17700 if(!isWasmInitialized) {
17701 throw new Error("initializeWasm() must be awaited first!");
17703 const nativeResponseValue = wasm.TS_FundingLocked_set_channel_id(this_ptr, val);
17704 // debug statements here
17706 // struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
17708 export function FundingLocked_get_next_per_commitment_point(this_ptr: number): number {
17709 if(!isWasmInitialized) {
17710 throw new Error("initializeWasm() must be awaited first!");
17712 const nativeResponseValue = wasm.TS_FundingLocked_get_next_per_commitment_point(this_ptr);
17713 return nativeResponseValue;
17715 // void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17717 export function FundingLocked_set_next_per_commitment_point(this_ptr: number, val: number): void {
17718 if(!isWasmInitialized) {
17719 throw new Error("initializeWasm() must be awaited first!");
17721 const nativeResponseValue = wasm.TS_FundingLocked_set_next_per_commitment_point(this_ptr, val);
17722 // debug statements here
17724 // MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
17726 export function FundingLocked_new(channel_id_arg: number, next_per_commitment_point_arg: number): number {
17727 if(!isWasmInitialized) {
17728 throw new Error("initializeWasm() must be awaited first!");
17730 const nativeResponseValue = wasm.TS_FundingLocked_new(channel_id_arg, next_per_commitment_point_arg);
17731 return nativeResponseValue;
17733 // uintptr_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
17735 export function FundingLocked_clone_ptr(arg: number): number {
17736 if(!isWasmInitialized) {
17737 throw new Error("initializeWasm() must be awaited first!");
17739 const nativeResponseValue = wasm.TS_FundingLocked_clone_ptr(arg);
17740 return nativeResponseValue;
17742 // struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
17744 export function FundingLocked_clone(orig: number): number {
17745 if(!isWasmInitialized) {
17746 throw new Error("initializeWasm() must be awaited first!");
17748 const nativeResponseValue = wasm.TS_FundingLocked_clone(orig);
17749 return nativeResponseValue;
17751 // void Shutdown_free(struct LDKShutdown this_obj);
17753 export function Shutdown_free(this_obj: number): void {
17754 if(!isWasmInitialized) {
17755 throw new Error("initializeWasm() must be awaited first!");
17757 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
17758 // debug statements here
17760 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
17762 export function Shutdown_get_channel_id(this_ptr: number): number {
17763 if(!isWasmInitialized) {
17764 throw new Error("initializeWasm() must be awaited first!");
17766 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
17767 return nativeResponseValue;
17769 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17771 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
17772 if(!isWasmInitialized) {
17773 throw new Error("initializeWasm() must be awaited first!");
17775 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
17776 // debug statements here
17778 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
17780 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
17781 if(!isWasmInitialized) {
17782 throw new Error("initializeWasm() must be awaited first!");
17784 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
17785 return nativeResponseValue;
17787 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17789 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
17790 if(!isWasmInitialized) {
17791 throw new Error("initializeWasm() must be awaited first!");
17793 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
17794 // debug statements here
17796 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
17798 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
17799 if(!isWasmInitialized) {
17800 throw new Error("initializeWasm() must be awaited first!");
17802 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
17803 return nativeResponseValue;
17805 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
17807 export function Shutdown_clone_ptr(arg: number): number {
17808 if(!isWasmInitialized) {
17809 throw new Error("initializeWasm() must be awaited first!");
17811 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
17812 return nativeResponseValue;
17814 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
17816 export function Shutdown_clone(orig: number): number {
17817 if(!isWasmInitialized) {
17818 throw new Error("initializeWasm() must be awaited first!");
17820 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
17821 return nativeResponseValue;
17823 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
17825 export function ClosingSignedFeeRange_free(this_obj: number): void {
17826 if(!isWasmInitialized) {
17827 throw new Error("initializeWasm() must be awaited first!");
17829 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
17830 // debug statements here
17832 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
17834 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
17835 if(!isWasmInitialized) {
17836 throw new Error("initializeWasm() must be awaited first!");
17838 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
17839 return nativeResponseValue;
17841 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
17843 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
17844 if(!isWasmInitialized) {
17845 throw new Error("initializeWasm() must be awaited first!");
17847 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
17848 // debug statements here
17850 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
17852 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
17853 if(!isWasmInitialized) {
17854 throw new Error("initializeWasm() must be awaited first!");
17856 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
17857 return nativeResponseValue;
17859 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
17861 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
17862 if(!isWasmInitialized) {
17863 throw new Error("initializeWasm() must be awaited first!");
17865 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
17866 // debug statements here
17868 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
17870 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
17871 if(!isWasmInitialized) {
17872 throw new Error("initializeWasm() must be awaited first!");
17874 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
17875 return nativeResponseValue;
17877 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
17879 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
17880 if(!isWasmInitialized) {
17881 throw new Error("initializeWasm() must be awaited first!");
17883 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
17884 return nativeResponseValue;
17886 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
17888 export function ClosingSignedFeeRange_clone(orig: number): number {
17889 if(!isWasmInitialized) {
17890 throw new Error("initializeWasm() must be awaited first!");
17892 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
17893 return nativeResponseValue;
17895 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
17897 export function ClosingSigned_free(this_obj: number): void {
17898 if(!isWasmInitialized) {
17899 throw new Error("initializeWasm() must be awaited first!");
17901 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
17902 // debug statements here
17904 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
17906 export function ClosingSigned_get_channel_id(this_ptr: number): number {
17907 if(!isWasmInitialized) {
17908 throw new Error("initializeWasm() must be awaited first!");
17910 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
17911 return nativeResponseValue;
17913 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17915 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
17916 if(!isWasmInitialized) {
17917 throw new Error("initializeWasm() must be awaited first!");
17919 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
17920 // debug statements here
17922 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
17924 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
17925 if(!isWasmInitialized) {
17926 throw new Error("initializeWasm() must be awaited first!");
17928 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
17929 return nativeResponseValue;
17931 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
17933 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
17934 if(!isWasmInitialized) {
17935 throw new Error("initializeWasm() must be awaited first!");
17937 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
17938 // debug statements here
17940 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
17942 export function ClosingSigned_get_signature(this_ptr: number): number {
17943 if(!isWasmInitialized) {
17944 throw new Error("initializeWasm() must be awaited first!");
17946 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
17947 return nativeResponseValue;
17949 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
17951 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
17952 if(!isWasmInitialized) {
17953 throw new Error("initializeWasm() must be awaited first!");
17955 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
17956 // debug statements here
17958 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
17960 export function ClosingSigned_get_fee_range(this_ptr: number): number {
17961 if(!isWasmInitialized) {
17962 throw new Error("initializeWasm() must be awaited first!");
17964 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
17965 return nativeResponseValue;
17967 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
17969 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
17970 if(!isWasmInitialized) {
17971 throw new Error("initializeWasm() must be awaited first!");
17973 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
17974 // debug statements here
17976 // 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);
17978 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
17979 if(!isWasmInitialized) {
17980 throw new Error("initializeWasm() must be awaited first!");
17982 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
17983 return nativeResponseValue;
17985 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
17987 export function ClosingSigned_clone_ptr(arg: number): number {
17988 if(!isWasmInitialized) {
17989 throw new Error("initializeWasm() must be awaited first!");
17991 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
17992 return nativeResponseValue;
17994 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
17996 export function ClosingSigned_clone(orig: number): number {
17997 if(!isWasmInitialized) {
17998 throw new Error("initializeWasm() must be awaited first!");
18000 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
18001 return nativeResponseValue;
18003 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
18005 export function UpdateAddHTLC_free(this_obj: number): void {
18006 if(!isWasmInitialized) {
18007 throw new Error("initializeWasm() must be awaited first!");
18009 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
18010 // debug statements here
18012 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
18014 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
18015 if(!isWasmInitialized) {
18016 throw new Error("initializeWasm() must be awaited first!");
18018 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
18019 return nativeResponseValue;
18021 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18023 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
18024 if(!isWasmInitialized) {
18025 throw new Error("initializeWasm() must be awaited first!");
18027 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
18028 // debug statements here
18030 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
18032 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
18033 if(!isWasmInitialized) {
18034 throw new Error("initializeWasm() must be awaited first!");
18036 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
18037 return nativeResponseValue;
18039 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
18041 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18042 if(!isWasmInitialized) {
18043 throw new Error("initializeWasm() must be awaited first!");
18045 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
18046 // debug statements here
18048 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
18050 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
18051 if(!isWasmInitialized) {
18052 throw new Error("initializeWasm() must be awaited first!");
18054 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
18055 return nativeResponseValue;
18057 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
18059 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
18060 if(!isWasmInitialized) {
18061 throw new Error("initializeWasm() must be awaited first!");
18063 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
18064 // debug statements here
18066 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
18068 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
18069 if(!isWasmInitialized) {
18070 throw new Error("initializeWasm() must be awaited first!");
18072 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
18073 return nativeResponseValue;
18075 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18077 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
18078 if(!isWasmInitialized) {
18079 throw new Error("initializeWasm() must be awaited first!");
18081 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
18082 // debug statements here
18084 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
18086 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
18087 if(!isWasmInitialized) {
18088 throw new Error("initializeWasm() must be awaited first!");
18090 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
18091 return nativeResponseValue;
18093 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
18095 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
18096 if(!isWasmInitialized) {
18097 throw new Error("initializeWasm() must be awaited first!");
18099 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
18100 // debug statements here
18102 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
18104 export function UpdateAddHTLC_clone_ptr(arg: number): number {
18105 if(!isWasmInitialized) {
18106 throw new Error("initializeWasm() must be awaited first!");
18108 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
18109 return nativeResponseValue;
18111 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
18113 export function UpdateAddHTLC_clone(orig: number): number {
18114 if(!isWasmInitialized) {
18115 throw new Error("initializeWasm() must be awaited first!");
18117 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
18118 return nativeResponseValue;
18120 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
18122 export function UpdateFulfillHTLC_free(this_obj: number): void {
18123 if(!isWasmInitialized) {
18124 throw new Error("initializeWasm() must be awaited first!");
18126 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
18127 // debug statements here
18129 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
18131 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
18132 if(!isWasmInitialized) {
18133 throw new Error("initializeWasm() must be awaited first!");
18135 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
18136 return nativeResponseValue;
18138 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18140 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
18141 if(!isWasmInitialized) {
18142 throw new Error("initializeWasm() must be awaited first!");
18144 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
18145 // debug statements here
18147 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
18149 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
18150 if(!isWasmInitialized) {
18151 throw new Error("initializeWasm() must be awaited first!");
18153 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
18154 return nativeResponseValue;
18156 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
18158 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18159 if(!isWasmInitialized) {
18160 throw new Error("initializeWasm() must be awaited first!");
18162 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
18163 // debug statements here
18165 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
18167 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
18168 if(!isWasmInitialized) {
18169 throw new Error("initializeWasm() must be awaited first!");
18171 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
18172 return nativeResponseValue;
18174 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18176 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
18177 if(!isWasmInitialized) {
18178 throw new Error("initializeWasm() must be awaited first!");
18180 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
18181 // debug statements here
18183 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
18185 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
18186 if(!isWasmInitialized) {
18187 throw new Error("initializeWasm() must be awaited first!");
18189 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
18190 return nativeResponseValue;
18192 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
18194 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
18195 if(!isWasmInitialized) {
18196 throw new Error("initializeWasm() must be awaited first!");
18198 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
18199 return nativeResponseValue;
18201 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
18203 export function UpdateFulfillHTLC_clone(orig: number): number {
18204 if(!isWasmInitialized) {
18205 throw new Error("initializeWasm() must be awaited first!");
18207 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
18208 return nativeResponseValue;
18210 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
18212 export function UpdateFailHTLC_free(this_obj: number): void {
18213 if(!isWasmInitialized) {
18214 throw new Error("initializeWasm() must be awaited first!");
18216 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
18217 // debug statements here
18219 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
18221 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
18222 if(!isWasmInitialized) {
18223 throw new Error("initializeWasm() must be awaited first!");
18225 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
18226 return nativeResponseValue;
18228 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18230 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
18231 if(!isWasmInitialized) {
18232 throw new Error("initializeWasm() must be awaited first!");
18234 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
18235 // debug statements here
18237 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
18239 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
18240 if(!isWasmInitialized) {
18241 throw new Error("initializeWasm() must be awaited first!");
18243 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
18244 return nativeResponseValue;
18246 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
18248 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18249 if(!isWasmInitialized) {
18250 throw new Error("initializeWasm() must be awaited first!");
18252 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
18253 // debug statements here
18255 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
18257 export function UpdateFailHTLC_clone_ptr(arg: number): number {
18258 if(!isWasmInitialized) {
18259 throw new Error("initializeWasm() must be awaited first!");
18261 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
18262 return nativeResponseValue;
18264 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
18266 export function UpdateFailHTLC_clone(orig: number): number {
18267 if(!isWasmInitialized) {
18268 throw new Error("initializeWasm() must be awaited first!");
18270 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
18271 return nativeResponseValue;
18273 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
18275 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
18276 if(!isWasmInitialized) {
18277 throw new Error("initializeWasm() must be awaited first!");
18279 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
18280 // debug statements here
18282 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
18284 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
18285 if(!isWasmInitialized) {
18286 throw new Error("initializeWasm() must be awaited first!");
18288 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
18289 return nativeResponseValue;
18291 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18293 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
18294 if(!isWasmInitialized) {
18295 throw new Error("initializeWasm() must be awaited first!");
18297 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
18298 // debug statements here
18300 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
18302 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
18303 if(!isWasmInitialized) {
18304 throw new Error("initializeWasm() must be awaited first!");
18306 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
18307 return nativeResponseValue;
18309 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
18311 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18312 if(!isWasmInitialized) {
18313 throw new Error("initializeWasm() must be awaited first!");
18315 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
18316 // debug statements here
18318 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
18320 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
18321 if(!isWasmInitialized) {
18322 throw new Error("initializeWasm() must be awaited first!");
18324 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
18325 return nativeResponseValue;
18327 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
18329 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
18330 if(!isWasmInitialized) {
18331 throw new Error("initializeWasm() must be awaited first!");
18333 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
18334 // debug statements here
18336 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
18338 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
18339 if(!isWasmInitialized) {
18340 throw new Error("initializeWasm() must be awaited first!");
18342 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
18343 return nativeResponseValue;
18345 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
18347 export function UpdateFailMalformedHTLC_clone(orig: number): number {
18348 if(!isWasmInitialized) {
18349 throw new Error("initializeWasm() must be awaited first!");
18351 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
18352 return nativeResponseValue;
18354 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
18356 export function CommitmentSigned_free(this_obj: number): void {
18357 if(!isWasmInitialized) {
18358 throw new Error("initializeWasm() must be awaited first!");
18360 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
18361 // debug statements here
18363 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
18365 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
18366 if(!isWasmInitialized) {
18367 throw new Error("initializeWasm() must be awaited first!");
18369 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
18370 return nativeResponseValue;
18372 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18374 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
18375 if(!isWasmInitialized) {
18376 throw new Error("initializeWasm() must be awaited first!");
18378 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
18379 // debug statements here
18381 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
18383 export function CommitmentSigned_get_signature(this_ptr: number): number {
18384 if(!isWasmInitialized) {
18385 throw new Error("initializeWasm() must be awaited first!");
18387 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
18388 return nativeResponseValue;
18390 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
18392 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
18393 if(!isWasmInitialized) {
18394 throw new Error("initializeWasm() must be awaited first!");
18396 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
18397 // debug statements here
18399 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
18401 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
18402 if(!isWasmInitialized) {
18403 throw new Error("initializeWasm() must be awaited first!");
18405 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
18406 // debug statements here
18408 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
18410 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
18411 if(!isWasmInitialized) {
18412 throw new Error("initializeWasm() must be awaited first!");
18414 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
18415 return nativeResponseValue;
18417 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
18419 export function CommitmentSigned_clone_ptr(arg: number): number {
18420 if(!isWasmInitialized) {
18421 throw new Error("initializeWasm() must be awaited first!");
18423 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
18424 return nativeResponseValue;
18426 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
18428 export function CommitmentSigned_clone(orig: number): number {
18429 if(!isWasmInitialized) {
18430 throw new Error("initializeWasm() must be awaited first!");
18432 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
18433 return nativeResponseValue;
18435 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
18437 export function RevokeAndACK_free(this_obj: number): void {
18438 if(!isWasmInitialized) {
18439 throw new Error("initializeWasm() must be awaited first!");
18441 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
18442 // debug statements here
18444 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
18446 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
18447 if(!isWasmInitialized) {
18448 throw new Error("initializeWasm() must be awaited first!");
18450 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
18451 return nativeResponseValue;
18453 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18455 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
18456 if(!isWasmInitialized) {
18457 throw new Error("initializeWasm() must be awaited first!");
18459 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
18460 // debug statements here
18462 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
18464 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
18465 if(!isWasmInitialized) {
18466 throw new Error("initializeWasm() must be awaited first!");
18468 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
18469 return nativeResponseValue;
18471 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18473 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
18474 if(!isWasmInitialized) {
18475 throw new Error("initializeWasm() must be awaited first!");
18477 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
18478 // debug statements here
18480 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
18482 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
18483 if(!isWasmInitialized) {
18484 throw new Error("initializeWasm() must be awaited first!");
18486 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
18487 return nativeResponseValue;
18489 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18491 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
18492 if(!isWasmInitialized) {
18493 throw new Error("initializeWasm() must be awaited first!");
18495 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
18496 // debug statements here
18498 // 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);
18500 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
18501 if(!isWasmInitialized) {
18502 throw new Error("initializeWasm() must be awaited first!");
18504 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
18505 return nativeResponseValue;
18507 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
18509 export function RevokeAndACK_clone_ptr(arg: number): number {
18510 if(!isWasmInitialized) {
18511 throw new Error("initializeWasm() must be awaited first!");
18513 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
18514 return nativeResponseValue;
18516 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
18518 export function RevokeAndACK_clone(orig: number): number {
18519 if(!isWasmInitialized) {
18520 throw new Error("initializeWasm() must be awaited first!");
18522 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
18523 return nativeResponseValue;
18525 // void UpdateFee_free(struct LDKUpdateFee this_obj);
18527 export function UpdateFee_free(this_obj: number): void {
18528 if(!isWasmInitialized) {
18529 throw new Error("initializeWasm() must be awaited first!");
18531 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
18532 // debug statements here
18534 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
18536 export function UpdateFee_get_channel_id(this_ptr: number): number {
18537 if(!isWasmInitialized) {
18538 throw new Error("initializeWasm() must be awaited first!");
18540 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
18541 return nativeResponseValue;
18543 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18545 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
18546 if(!isWasmInitialized) {
18547 throw new Error("initializeWasm() must be awaited first!");
18549 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
18550 // debug statements here
18552 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
18554 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
18555 if(!isWasmInitialized) {
18556 throw new Error("initializeWasm() must be awaited first!");
18558 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
18559 return nativeResponseValue;
18561 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
18563 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
18564 if(!isWasmInitialized) {
18565 throw new Error("initializeWasm() must be awaited first!");
18567 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
18568 // debug statements here
18570 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
18572 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
18573 if(!isWasmInitialized) {
18574 throw new Error("initializeWasm() must be awaited first!");
18576 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
18577 return nativeResponseValue;
18579 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
18581 export function UpdateFee_clone_ptr(arg: number): number {
18582 if(!isWasmInitialized) {
18583 throw new Error("initializeWasm() must be awaited first!");
18585 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
18586 return nativeResponseValue;
18588 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
18590 export function UpdateFee_clone(orig: number): number {
18591 if(!isWasmInitialized) {
18592 throw new Error("initializeWasm() must be awaited first!");
18594 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
18595 return nativeResponseValue;
18597 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
18599 export function DataLossProtect_free(this_obj: number): void {
18600 if(!isWasmInitialized) {
18601 throw new Error("initializeWasm() must be awaited first!");
18603 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
18604 // debug statements here
18606 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
18608 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
18609 if(!isWasmInitialized) {
18610 throw new Error("initializeWasm() must be awaited first!");
18612 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
18613 return nativeResponseValue;
18615 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18617 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
18618 if(!isWasmInitialized) {
18619 throw new Error("initializeWasm() must be awaited first!");
18621 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
18622 // debug statements here
18624 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
18626 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
18627 if(!isWasmInitialized) {
18628 throw new Error("initializeWasm() must be awaited first!");
18630 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
18631 return nativeResponseValue;
18633 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18635 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
18636 if(!isWasmInitialized) {
18637 throw new Error("initializeWasm() must be awaited first!");
18639 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
18640 // debug statements here
18642 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
18644 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
18645 if(!isWasmInitialized) {
18646 throw new Error("initializeWasm() must be awaited first!");
18648 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
18649 return nativeResponseValue;
18651 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
18653 export function DataLossProtect_clone_ptr(arg: number): number {
18654 if(!isWasmInitialized) {
18655 throw new Error("initializeWasm() must be awaited first!");
18657 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
18658 return nativeResponseValue;
18660 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
18662 export function DataLossProtect_clone(orig: number): number {
18663 if(!isWasmInitialized) {
18664 throw new Error("initializeWasm() must be awaited first!");
18666 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
18667 return nativeResponseValue;
18669 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
18671 export function ChannelReestablish_free(this_obj: number): void {
18672 if(!isWasmInitialized) {
18673 throw new Error("initializeWasm() must be awaited first!");
18675 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
18676 // debug statements here
18678 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
18680 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
18681 if(!isWasmInitialized) {
18682 throw new Error("initializeWasm() must be awaited first!");
18684 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
18685 return nativeResponseValue;
18687 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18689 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
18690 if(!isWasmInitialized) {
18691 throw new Error("initializeWasm() must be awaited first!");
18693 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
18694 // debug statements here
18696 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
18698 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
18699 if(!isWasmInitialized) {
18700 throw new Error("initializeWasm() must be awaited first!");
18702 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
18703 return nativeResponseValue;
18705 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
18707 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
18708 if(!isWasmInitialized) {
18709 throw new Error("initializeWasm() must be awaited first!");
18711 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
18712 // debug statements here
18714 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
18716 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
18717 if(!isWasmInitialized) {
18718 throw new Error("initializeWasm() must be awaited first!");
18720 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
18721 return nativeResponseValue;
18723 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
18725 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
18726 if(!isWasmInitialized) {
18727 throw new Error("initializeWasm() must be awaited first!");
18729 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
18730 // debug statements here
18732 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
18734 export function ChannelReestablish_clone_ptr(arg: number): number {
18735 if(!isWasmInitialized) {
18736 throw new Error("initializeWasm() must be awaited first!");
18738 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
18739 return nativeResponseValue;
18741 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
18743 export function ChannelReestablish_clone(orig: number): number {
18744 if(!isWasmInitialized) {
18745 throw new Error("initializeWasm() must be awaited first!");
18747 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
18748 return nativeResponseValue;
18750 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
18752 export function AnnouncementSignatures_free(this_obj: number): void {
18753 if(!isWasmInitialized) {
18754 throw new Error("initializeWasm() must be awaited first!");
18756 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
18757 // debug statements here
18759 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
18761 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
18762 if(!isWasmInitialized) {
18763 throw new Error("initializeWasm() must be awaited first!");
18765 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
18766 return nativeResponseValue;
18768 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18770 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
18771 if(!isWasmInitialized) {
18772 throw new Error("initializeWasm() must be awaited first!");
18774 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
18775 // debug statements here
18777 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
18779 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
18780 if(!isWasmInitialized) {
18781 throw new Error("initializeWasm() must be awaited first!");
18783 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
18784 return nativeResponseValue;
18786 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
18788 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
18789 if(!isWasmInitialized) {
18790 throw new Error("initializeWasm() must be awaited first!");
18792 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
18793 // debug statements here
18795 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
18797 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
18798 if(!isWasmInitialized) {
18799 throw new Error("initializeWasm() must be awaited first!");
18801 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
18802 return nativeResponseValue;
18804 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
18806 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
18807 if(!isWasmInitialized) {
18808 throw new Error("initializeWasm() must be awaited first!");
18810 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
18811 // debug statements here
18813 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
18815 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
18816 if(!isWasmInitialized) {
18817 throw new Error("initializeWasm() must be awaited first!");
18819 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
18820 return nativeResponseValue;
18822 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
18824 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
18825 if(!isWasmInitialized) {
18826 throw new Error("initializeWasm() must be awaited first!");
18828 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
18829 // debug statements here
18831 // 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);
18833 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
18834 if(!isWasmInitialized) {
18835 throw new Error("initializeWasm() must be awaited first!");
18837 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
18838 return nativeResponseValue;
18840 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
18842 export function AnnouncementSignatures_clone_ptr(arg: number): number {
18843 if(!isWasmInitialized) {
18844 throw new Error("initializeWasm() must be awaited first!");
18846 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
18847 return nativeResponseValue;
18849 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
18851 export function AnnouncementSignatures_clone(orig: number): number {
18852 if(!isWasmInitialized) {
18853 throw new Error("initializeWasm() must be awaited first!");
18855 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
18856 return nativeResponseValue;
18858 // void NetAddress_free(struct LDKNetAddress this_ptr);
18860 export function NetAddress_free(this_ptr: number): void {
18861 if(!isWasmInitialized) {
18862 throw new Error("initializeWasm() must be awaited first!");
18864 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
18865 // debug statements here
18867 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
18869 export function NetAddress_clone_ptr(arg: number): number {
18870 if(!isWasmInitialized) {
18871 throw new Error("initializeWasm() must be awaited first!");
18873 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
18874 return nativeResponseValue;
18876 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
18878 export function NetAddress_clone(orig: number): number {
18879 if(!isWasmInitialized) {
18880 throw new Error("initializeWasm() must be awaited first!");
18882 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
18883 return nativeResponseValue;
18885 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
18887 export function NetAddress_ipv4(addr: number, port: number): number {
18888 if(!isWasmInitialized) {
18889 throw new Error("initializeWasm() must be awaited first!");
18891 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
18892 return nativeResponseValue;
18894 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
18896 export function NetAddress_ipv6(addr: number, port: number): number {
18897 if(!isWasmInitialized) {
18898 throw new Error("initializeWasm() must be awaited first!");
18900 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
18901 return nativeResponseValue;
18903 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
18905 export function NetAddress_onion_v2(a: number): number {
18906 if(!isWasmInitialized) {
18907 throw new Error("initializeWasm() must be awaited first!");
18909 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
18910 return nativeResponseValue;
18912 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
18914 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
18915 if(!isWasmInitialized) {
18916 throw new Error("initializeWasm() must be awaited first!");
18918 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
18919 return nativeResponseValue;
18921 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
18923 export function NetAddress_write(obj: number): number {
18924 if(!isWasmInitialized) {
18925 throw new Error("initializeWasm() must be awaited first!");
18927 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
18928 return nativeResponseValue;
18930 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
18932 export function NetAddress_read(ser: number): number {
18933 if(!isWasmInitialized) {
18934 throw new Error("initializeWasm() must be awaited first!");
18936 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
18937 return nativeResponseValue;
18939 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
18941 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
18942 if(!isWasmInitialized) {
18943 throw new Error("initializeWasm() must be awaited first!");
18945 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
18946 // debug statements here
18948 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
18950 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
18951 if(!isWasmInitialized) {
18952 throw new Error("initializeWasm() must be awaited first!");
18954 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
18955 return nativeResponseValue;
18957 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
18959 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
18960 if(!isWasmInitialized) {
18961 throw new Error("initializeWasm() must be awaited first!");
18963 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
18964 // debug statements here
18966 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
18968 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
18969 if(!isWasmInitialized) {
18970 throw new Error("initializeWasm() must be awaited first!");
18972 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
18973 return nativeResponseValue;
18975 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
18977 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
18978 if(!isWasmInitialized) {
18979 throw new Error("initializeWasm() must be awaited first!");
18981 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
18982 // debug statements here
18984 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
18986 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
18987 if(!isWasmInitialized) {
18988 throw new Error("initializeWasm() must be awaited first!");
18990 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
18991 return nativeResponseValue;
18993 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18995 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
18996 if(!isWasmInitialized) {
18997 throw new Error("initializeWasm() must be awaited first!");
18999 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
19000 // debug statements here
19002 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
19004 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
19005 if(!isWasmInitialized) {
19006 throw new Error("initializeWasm() must be awaited first!");
19008 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
19009 return nativeResponseValue;
19011 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
19013 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
19014 if(!isWasmInitialized) {
19015 throw new Error("initializeWasm() must be awaited first!");
19017 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
19018 // debug statements here
19020 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
19022 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
19023 if(!isWasmInitialized) {
19024 throw new Error("initializeWasm() must be awaited first!");
19026 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
19027 return nativeResponseValue;
19029 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19031 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
19032 if(!isWasmInitialized) {
19033 throw new Error("initializeWasm() must be awaited first!");
19035 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
19036 // debug statements here
19038 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
19040 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
19041 if(!isWasmInitialized) {
19042 throw new Error("initializeWasm() must be awaited first!");
19044 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
19045 // debug statements here
19047 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
19049 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
19050 if(!isWasmInitialized) {
19051 throw new Error("initializeWasm() must be awaited first!");
19053 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
19054 return nativeResponseValue;
19056 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
19058 export function UnsignedNodeAnnouncement_clone(orig: number): number {
19059 if(!isWasmInitialized) {
19060 throw new Error("initializeWasm() must be awaited first!");
19062 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
19063 return nativeResponseValue;
19065 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
19067 export function NodeAnnouncement_free(this_obj: number): void {
19068 if(!isWasmInitialized) {
19069 throw new Error("initializeWasm() must be awaited first!");
19071 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
19072 // debug statements here
19074 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
19076 export function NodeAnnouncement_get_signature(this_ptr: number): number {
19077 if(!isWasmInitialized) {
19078 throw new Error("initializeWasm() must be awaited first!");
19080 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
19081 return nativeResponseValue;
19083 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19085 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
19086 if(!isWasmInitialized) {
19087 throw new Error("initializeWasm() must be awaited first!");
19089 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
19090 // debug statements here
19092 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
19094 export function NodeAnnouncement_get_contents(this_ptr: number): number {
19095 if(!isWasmInitialized) {
19096 throw new Error("initializeWasm() must be awaited first!");
19098 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
19099 return nativeResponseValue;
19101 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
19103 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
19104 if(!isWasmInitialized) {
19105 throw new Error("initializeWasm() must be awaited first!");
19107 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
19108 // debug statements here
19110 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
19112 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
19113 if(!isWasmInitialized) {
19114 throw new Error("initializeWasm() must be awaited first!");
19116 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
19117 return nativeResponseValue;
19119 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
19121 export function NodeAnnouncement_clone_ptr(arg: number): number {
19122 if(!isWasmInitialized) {
19123 throw new Error("initializeWasm() must be awaited first!");
19125 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
19126 return nativeResponseValue;
19128 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
19130 export function NodeAnnouncement_clone(orig: number): number {
19131 if(!isWasmInitialized) {
19132 throw new Error("initializeWasm() must be awaited first!");
19134 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
19135 return nativeResponseValue;
19137 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
19139 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
19140 if(!isWasmInitialized) {
19141 throw new Error("initializeWasm() must be awaited first!");
19143 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
19144 // debug statements here
19146 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19148 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
19149 if(!isWasmInitialized) {
19150 throw new Error("initializeWasm() must be awaited first!");
19152 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
19153 return nativeResponseValue;
19155 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
19157 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
19158 if(!isWasmInitialized) {
19159 throw new Error("initializeWasm() must be awaited first!");
19161 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
19162 // debug statements here
19164 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
19166 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
19167 if(!isWasmInitialized) {
19168 throw new Error("initializeWasm() must be awaited first!");
19170 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
19171 return nativeResponseValue;
19173 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19175 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
19176 if(!isWasmInitialized) {
19177 throw new Error("initializeWasm() must be awaited first!");
19179 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
19180 // debug statements here
19182 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19184 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
19185 if(!isWasmInitialized) {
19186 throw new Error("initializeWasm() must be awaited first!");
19188 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
19189 return nativeResponseValue;
19191 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
19193 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
19194 if(!isWasmInitialized) {
19195 throw new Error("initializeWasm() must be awaited first!");
19197 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
19198 // debug statements here
19200 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19202 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
19203 if(!isWasmInitialized) {
19204 throw new Error("initializeWasm() must be awaited first!");
19206 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
19207 return nativeResponseValue;
19209 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19211 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
19212 if(!isWasmInitialized) {
19213 throw new Error("initializeWasm() must be awaited first!");
19215 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
19216 // debug statements here
19218 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19220 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
19221 if(!isWasmInitialized) {
19222 throw new Error("initializeWasm() must be awaited first!");
19224 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
19225 return nativeResponseValue;
19227 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19229 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
19230 if(!isWasmInitialized) {
19231 throw new Error("initializeWasm() must be awaited first!");
19233 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
19234 // debug statements here
19236 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19238 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
19239 if(!isWasmInitialized) {
19240 throw new Error("initializeWasm() must be awaited first!");
19242 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
19243 return nativeResponseValue;
19245 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19247 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
19248 if(!isWasmInitialized) {
19249 throw new Error("initializeWasm() must be awaited first!");
19251 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
19252 // debug statements here
19254 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19256 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
19257 if(!isWasmInitialized) {
19258 throw new Error("initializeWasm() must be awaited first!");
19260 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
19261 return nativeResponseValue;
19263 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19265 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
19266 if(!isWasmInitialized) {
19267 throw new Error("initializeWasm() must be awaited first!");
19269 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
19270 // debug statements here
19272 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
19274 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
19275 if(!isWasmInitialized) {
19276 throw new Error("initializeWasm() must be awaited first!");
19278 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
19279 return nativeResponseValue;
19281 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
19283 export function UnsignedChannelAnnouncement_clone(orig: number): number {
19284 if(!isWasmInitialized) {
19285 throw new Error("initializeWasm() must be awaited first!");
19287 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
19288 return nativeResponseValue;
19290 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
19292 export function ChannelAnnouncement_free(this_obj: number): void {
19293 if(!isWasmInitialized) {
19294 throw new Error("initializeWasm() must be awaited first!");
19296 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
19297 // debug statements here
19299 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19301 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
19302 if(!isWasmInitialized) {
19303 throw new Error("initializeWasm() must be awaited first!");
19305 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
19306 return nativeResponseValue;
19308 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19310 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
19311 if(!isWasmInitialized) {
19312 throw new Error("initializeWasm() must be awaited first!");
19314 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
19315 // debug statements here
19317 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19319 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
19320 if(!isWasmInitialized) {
19321 throw new Error("initializeWasm() must be awaited first!");
19323 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
19324 return nativeResponseValue;
19326 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19328 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
19329 if(!isWasmInitialized) {
19330 throw new Error("initializeWasm() must be awaited first!");
19332 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
19333 // debug statements here
19335 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19337 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
19338 if(!isWasmInitialized) {
19339 throw new Error("initializeWasm() must be awaited first!");
19341 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
19342 return nativeResponseValue;
19344 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19346 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
19347 if(!isWasmInitialized) {
19348 throw new Error("initializeWasm() must be awaited first!");
19350 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
19351 // debug statements here
19353 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19355 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
19356 if(!isWasmInitialized) {
19357 throw new Error("initializeWasm() must be awaited first!");
19359 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
19360 return nativeResponseValue;
19362 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19364 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
19365 if(!isWasmInitialized) {
19366 throw new Error("initializeWasm() must be awaited first!");
19368 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
19369 // debug statements here
19371 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19373 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
19374 if(!isWasmInitialized) {
19375 throw new Error("initializeWasm() must be awaited first!");
19377 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
19378 return nativeResponseValue;
19380 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
19382 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
19383 if(!isWasmInitialized) {
19384 throw new Error("initializeWasm() must be awaited first!");
19386 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
19387 // debug statements here
19389 // 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);
19391 export function ChannelAnnouncement_new(node_signature_1_arg: number, node_signature_2_arg: number, bitcoin_signature_1_arg: number, bitcoin_signature_2_arg: number, contents_arg: number): number {
19392 if(!isWasmInitialized) {
19393 throw new Error("initializeWasm() must be awaited first!");
19395 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
19396 return nativeResponseValue;
19398 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
19400 export function ChannelAnnouncement_clone_ptr(arg: number): number {
19401 if(!isWasmInitialized) {
19402 throw new Error("initializeWasm() must be awaited first!");
19404 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
19405 return nativeResponseValue;
19407 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
19409 export function ChannelAnnouncement_clone(orig: number): number {
19410 if(!isWasmInitialized) {
19411 throw new Error("initializeWasm() must be awaited first!");
19413 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
19414 return nativeResponseValue;
19416 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
19418 export function UnsignedChannelUpdate_free(this_obj: number): void {
19419 if(!isWasmInitialized) {
19420 throw new Error("initializeWasm() must be awaited first!");
19422 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
19423 // debug statements here
19425 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
19427 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
19428 if(!isWasmInitialized) {
19429 throw new Error("initializeWasm() must be awaited first!");
19431 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
19432 return nativeResponseValue;
19434 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19436 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
19437 if(!isWasmInitialized) {
19438 throw new Error("initializeWasm() must be awaited first!");
19440 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
19441 // debug statements here
19443 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19445 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
19446 if(!isWasmInitialized) {
19447 throw new Error("initializeWasm() must be awaited first!");
19449 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
19450 return nativeResponseValue;
19452 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
19454 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
19455 if(!isWasmInitialized) {
19456 throw new Error("initializeWasm() must be awaited first!");
19458 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
19459 // debug statements here
19461 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19463 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
19464 if(!isWasmInitialized) {
19465 throw new Error("initializeWasm() must be awaited first!");
19467 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
19468 return nativeResponseValue;
19470 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
19472 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
19473 if(!isWasmInitialized) {
19474 throw new Error("initializeWasm() must be awaited first!");
19476 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
19477 // debug statements here
19479 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19481 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
19482 if(!isWasmInitialized) {
19483 throw new Error("initializeWasm() must be awaited first!");
19485 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
19486 return nativeResponseValue;
19488 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
19490 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
19491 if(!isWasmInitialized) {
19492 throw new Error("initializeWasm() must be awaited first!");
19494 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
19495 // debug statements here
19497 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19499 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
19500 if(!isWasmInitialized) {
19501 throw new Error("initializeWasm() must be awaited first!");
19503 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
19504 return nativeResponseValue;
19506 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
19508 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
19509 if(!isWasmInitialized) {
19510 throw new Error("initializeWasm() must be awaited first!");
19512 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
19513 // debug statements here
19515 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19517 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
19518 if(!isWasmInitialized) {
19519 throw new Error("initializeWasm() must be awaited first!");
19521 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
19522 return nativeResponseValue;
19524 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
19526 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
19527 if(!isWasmInitialized) {
19528 throw new Error("initializeWasm() must be awaited first!");
19530 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
19531 // debug statements here
19533 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19535 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
19536 if(!isWasmInitialized) {
19537 throw new Error("initializeWasm() must be awaited first!");
19539 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
19540 return nativeResponseValue;
19542 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
19544 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
19545 if(!isWasmInitialized) {
19546 throw new Error("initializeWasm() must be awaited first!");
19548 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
19549 // debug statements here
19551 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19553 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
19554 if(!isWasmInitialized) {
19555 throw new Error("initializeWasm() must be awaited first!");
19557 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
19558 return nativeResponseValue;
19560 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
19562 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
19563 if(!isWasmInitialized) {
19564 throw new Error("initializeWasm() must be awaited first!");
19566 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
19567 // debug statements here
19569 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
19571 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
19572 if(!isWasmInitialized) {
19573 throw new Error("initializeWasm() must be awaited first!");
19575 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
19576 return nativeResponseValue;
19578 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
19580 export function UnsignedChannelUpdate_clone(orig: number): number {
19581 if(!isWasmInitialized) {
19582 throw new Error("initializeWasm() must be awaited first!");
19584 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
19585 return nativeResponseValue;
19587 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
19589 export function ChannelUpdate_free(this_obj: number): void {
19590 if(!isWasmInitialized) {
19591 throw new Error("initializeWasm() must be awaited first!");
19593 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
19594 // debug statements here
19596 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
19598 export function ChannelUpdate_get_signature(this_ptr: number): number {
19599 if(!isWasmInitialized) {
19600 throw new Error("initializeWasm() must be awaited first!");
19602 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
19603 return nativeResponseValue;
19605 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
19607 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
19608 if(!isWasmInitialized) {
19609 throw new Error("initializeWasm() must be awaited first!");
19611 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
19612 // debug statements here
19614 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
19616 export function ChannelUpdate_get_contents(this_ptr: number): number {
19617 if(!isWasmInitialized) {
19618 throw new Error("initializeWasm() must be awaited first!");
19620 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
19621 return nativeResponseValue;
19623 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
19625 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
19626 if(!isWasmInitialized) {
19627 throw new Error("initializeWasm() must be awaited first!");
19629 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
19630 // debug statements here
19632 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
19634 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
19635 if(!isWasmInitialized) {
19636 throw new Error("initializeWasm() must be awaited first!");
19638 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
19639 return nativeResponseValue;
19641 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
19643 export function ChannelUpdate_clone_ptr(arg: number): number {
19644 if(!isWasmInitialized) {
19645 throw new Error("initializeWasm() must be awaited first!");
19647 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
19648 return nativeResponseValue;
19650 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
19652 export function ChannelUpdate_clone(orig: number): number {
19653 if(!isWasmInitialized) {
19654 throw new Error("initializeWasm() must be awaited first!");
19656 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
19657 return nativeResponseValue;
19659 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
19661 export function QueryChannelRange_free(this_obj: number): void {
19662 if(!isWasmInitialized) {
19663 throw new Error("initializeWasm() must be awaited first!");
19665 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
19666 // debug statements here
19668 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
19670 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
19671 if(!isWasmInitialized) {
19672 throw new Error("initializeWasm() must be awaited first!");
19674 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
19675 return nativeResponseValue;
19677 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19679 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
19680 if(!isWasmInitialized) {
19681 throw new Error("initializeWasm() must be awaited first!");
19683 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
19684 // debug statements here
19686 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
19688 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
19689 if(!isWasmInitialized) {
19690 throw new Error("initializeWasm() must be awaited first!");
19692 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
19693 return nativeResponseValue;
19695 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19697 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
19698 if(!isWasmInitialized) {
19699 throw new Error("initializeWasm() must be awaited first!");
19701 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
19702 // debug statements here
19704 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
19706 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
19707 if(!isWasmInitialized) {
19708 throw new Error("initializeWasm() must be awaited first!");
19710 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
19711 return nativeResponseValue;
19713 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19715 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
19716 if(!isWasmInitialized) {
19717 throw new Error("initializeWasm() must be awaited first!");
19719 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
19720 // debug statements here
19722 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
19724 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
19725 if(!isWasmInitialized) {
19726 throw new Error("initializeWasm() must be awaited first!");
19728 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
19729 return nativeResponseValue;
19731 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
19733 export function QueryChannelRange_clone_ptr(arg: number): number {
19734 if(!isWasmInitialized) {
19735 throw new Error("initializeWasm() must be awaited first!");
19737 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
19738 return nativeResponseValue;
19740 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
19742 export function QueryChannelRange_clone(orig: number): number {
19743 if(!isWasmInitialized) {
19744 throw new Error("initializeWasm() must be awaited first!");
19746 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
19747 return nativeResponseValue;
19749 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
19751 export function ReplyChannelRange_free(this_obj: number): void {
19752 if(!isWasmInitialized) {
19753 throw new Error("initializeWasm() must be awaited first!");
19755 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
19756 // debug statements here
19758 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
19760 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
19761 if(!isWasmInitialized) {
19762 throw new Error("initializeWasm() must be awaited first!");
19764 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
19765 return nativeResponseValue;
19767 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19769 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
19770 if(!isWasmInitialized) {
19771 throw new Error("initializeWasm() must be awaited first!");
19773 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
19774 // debug statements here
19776 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
19778 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
19779 if(!isWasmInitialized) {
19780 throw new Error("initializeWasm() must be awaited first!");
19782 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
19783 return nativeResponseValue;
19785 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19787 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
19788 if(!isWasmInitialized) {
19789 throw new Error("initializeWasm() must be awaited first!");
19791 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
19792 // debug statements here
19794 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
19796 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
19797 if(!isWasmInitialized) {
19798 throw new Error("initializeWasm() must be awaited first!");
19800 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
19801 return nativeResponseValue;
19803 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19805 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
19806 if(!isWasmInitialized) {
19807 throw new Error("initializeWasm() must be awaited first!");
19809 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
19810 // debug statements here
19812 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
19814 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
19815 if(!isWasmInitialized) {
19816 throw new Error("initializeWasm() must be awaited first!");
19818 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
19819 return nativeResponseValue;
19821 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
19823 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
19824 if(!isWasmInitialized) {
19825 throw new Error("initializeWasm() must be awaited first!");
19827 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
19828 // debug statements here
19830 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
19832 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
19833 if(!isWasmInitialized) {
19834 throw new Error("initializeWasm() must be awaited first!");
19836 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
19837 // debug statements here
19839 // 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);
19841 export function ReplyChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number, sync_complete_arg: boolean, short_channel_ids_arg: number): number {
19842 if(!isWasmInitialized) {
19843 throw new Error("initializeWasm() must be awaited first!");
19845 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
19846 return nativeResponseValue;
19848 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
19850 export function ReplyChannelRange_clone_ptr(arg: number): number {
19851 if(!isWasmInitialized) {
19852 throw new Error("initializeWasm() must be awaited first!");
19854 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
19855 return nativeResponseValue;
19857 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
19859 export function ReplyChannelRange_clone(orig: number): number {
19860 if(!isWasmInitialized) {
19861 throw new Error("initializeWasm() must be awaited first!");
19863 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
19864 return nativeResponseValue;
19866 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
19868 export function QueryShortChannelIds_free(this_obj: number): void {
19869 if(!isWasmInitialized) {
19870 throw new Error("initializeWasm() must be awaited first!");
19872 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
19873 // debug statements here
19875 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
19877 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
19878 if(!isWasmInitialized) {
19879 throw new Error("initializeWasm() must be awaited first!");
19881 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
19882 return nativeResponseValue;
19884 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19886 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
19887 if(!isWasmInitialized) {
19888 throw new Error("initializeWasm() must be awaited first!");
19890 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
19891 // debug statements here
19893 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
19895 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
19896 if(!isWasmInitialized) {
19897 throw new Error("initializeWasm() must be awaited first!");
19899 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
19900 // debug statements here
19902 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
19904 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
19905 if(!isWasmInitialized) {
19906 throw new Error("initializeWasm() must be awaited first!");
19908 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
19909 return nativeResponseValue;
19911 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
19913 export function QueryShortChannelIds_clone_ptr(arg: number): number {
19914 if(!isWasmInitialized) {
19915 throw new Error("initializeWasm() must be awaited first!");
19917 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
19918 return nativeResponseValue;
19920 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
19922 export function QueryShortChannelIds_clone(orig: number): number {
19923 if(!isWasmInitialized) {
19924 throw new Error("initializeWasm() must be awaited first!");
19926 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
19927 return nativeResponseValue;
19929 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
19931 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
19932 if(!isWasmInitialized) {
19933 throw new Error("initializeWasm() must be awaited first!");
19935 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
19936 // debug statements here
19938 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
19940 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
19941 if(!isWasmInitialized) {
19942 throw new Error("initializeWasm() must be awaited first!");
19944 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
19945 return nativeResponseValue;
19947 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19949 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
19950 if(!isWasmInitialized) {
19951 throw new Error("initializeWasm() must be awaited first!");
19953 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
19954 // debug statements here
19956 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
19958 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
19959 if(!isWasmInitialized) {
19960 throw new Error("initializeWasm() must be awaited first!");
19962 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
19963 return nativeResponseValue;
19965 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
19967 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
19968 if(!isWasmInitialized) {
19969 throw new Error("initializeWasm() must be awaited first!");
19971 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
19972 // debug statements here
19974 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
19976 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
19977 if(!isWasmInitialized) {
19978 throw new Error("initializeWasm() must be awaited first!");
19980 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
19981 return nativeResponseValue;
19983 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
19985 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
19986 if(!isWasmInitialized) {
19987 throw new Error("initializeWasm() must be awaited first!");
19989 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
19990 return nativeResponseValue;
19992 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
19994 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
19995 if(!isWasmInitialized) {
19996 throw new Error("initializeWasm() must be awaited first!");
19998 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
19999 return nativeResponseValue;
20001 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
20003 export function GossipTimestampFilter_free(this_obj: number): void {
20004 if(!isWasmInitialized) {
20005 throw new Error("initializeWasm() must be awaited first!");
20007 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
20008 // debug statements here
20010 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
20012 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
20013 if(!isWasmInitialized) {
20014 throw new Error("initializeWasm() must be awaited first!");
20016 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
20017 return nativeResponseValue;
20019 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20021 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
20022 if(!isWasmInitialized) {
20023 throw new Error("initializeWasm() must be awaited first!");
20025 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
20026 // debug statements here
20028 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
20030 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
20031 if(!isWasmInitialized) {
20032 throw new Error("initializeWasm() must be awaited first!");
20034 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
20035 return nativeResponseValue;
20037 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
20039 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
20040 if(!isWasmInitialized) {
20041 throw new Error("initializeWasm() must be awaited first!");
20043 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
20044 // debug statements here
20046 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
20048 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
20049 if(!isWasmInitialized) {
20050 throw new Error("initializeWasm() must be awaited first!");
20052 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
20053 return nativeResponseValue;
20055 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
20057 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
20058 if(!isWasmInitialized) {
20059 throw new Error("initializeWasm() must be awaited first!");
20061 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
20062 // debug statements here
20064 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
20066 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
20067 if(!isWasmInitialized) {
20068 throw new Error("initializeWasm() must be awaited first!");
20070 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
20071 return nativeResponseValue;
20073 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
20075 export function GossipTimestampFilter_clone_ptr(arg: number): number {
20076 if(!isWasmInitialized) {
20077 throw new Error("initializeWasm() must be awaited first!");
20079 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
20080 return nativeResponseValue;
20082 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
20084 export function GossipTimestampFilter_clone(orig: number): number {
20085 if(!isWasmInitialized) {
20086 throw new Error("initializeWasm() must be awaited first!");
20088 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
20089 return nativeResponseValue;
20091 // void ErrorAction_free(struct LDKErrorAction this_ptr);
20093 export function ErrorAction_free(this_ptr: number): void {
20094 if(!isWasmInitialized) {
20095 throw new Error("initializeWasm() must be awaited first!");
20097 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
20098 // debug statements here
20100 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
20102 export function ErrorAction_clone_ptr(arg: number): number {
20103 if(!isWasmInitialized) {
20104 throw new Error("initializeWasm() must be awaited first!");
20106 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
20107 return nativeResponseValue;
20109 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
20111 export function ErrorAction_clone(orig: number): number {
20112 if(!isWasmInitialized) {
20113 throw new Error("initializeWasm() must be awaited first!");
20115 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
20116 return nativeResponseValue;
20118 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
20120 export function ErrorAction_disconnect_peer(msg: number): number {
20121 if(!isWasmInitialized) {
20122 throw new Error("initializeWasm() must be awaited first!");
20124 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
20125 return nativeResponseValue;
20127 // struct LDKErrorAction ErrorAction_ignore_error(void);
20129 export function ErrorAction_ignore_error(): number {
20130 if(!isWasmInitialized) {
20131 throw new Error("initializeWasm() must be awaited first!");
20133 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
20134 return nativeResponseValue;
20136 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
20138 export function ErrorAction_ignore_and_log(a: Level): number {
20139 if(!isWasmInitialized) {
20140 throw new Error("initializeWasm() must be awaited first!");
20142 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
20143 return nativeResponseValue;
20145 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
20147 export function ErrorAction_ignore_duplicate_gossip(): number {
20148 if(!isWasmInitialized) {
20149 throw new Error("initializeWasm() must be awaited first!");
20151 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
20152 return nativeResponseValue;
20154 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
20156 export function ErrorAction_send_error_message(msg: number): number {
20157 if(!isWasmInitialized) {
20158 throw new Error("initializeWasm() must be awaited first!");
20160 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
20161 return nativeResponseValue;
20163 // void LightningError_free(struct LDKLightningError this_obj);
20165 export function LightningError_free(this_obj: number): void {
20166 if(!isWasmInitialized) {
20167 throw new Error("initializeWasm() must be awaited first!");
20169 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
20170 // debug statements here
20172 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
20174 export function LightningError_get_err(this_ptr: number): number {
20175 if(!isWasmInitialized) {
20176 throw new Error("initializeWasm() must be awaited first!");
20178 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
20179 return nativeResponseValue;
20181 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
20183 export function LightningError_set_err(this_ptr: number, val: number): void {
20184 if(!isWasmInitialized) {
20185 throw new Error("initializeWasm() must be awaited first!");
20187 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
20188 // debug statements here
20190 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
20192 export function LightningError_get_action(this_ptr: number): number {
20193 if(!isWasmInitialized) {
20194 throw new Error("initializeWasm() must be awaited first!");
20196 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
20197 return nativeResponseValue;
20199 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
20201 export function LightningError_set_action(this_ptr: number, val: number): void {
20202 if(!isWasmInitialized) {
20203 throw new Error("initializeWasm() must be awaited first!");
20205 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
20206 // debug statements here
20208 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
20210 export function LightningError_new(err_arg: number, action_arg: number): number {
20211 if(!isWasmInitialized) {
20212 throw new Error("initializeWasm() must be awaited first!");
20214 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
20215 return nativeResponseValue;
20217 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
20219 export function LightningError_clone_ptr(arg: number): number {
20220 if(!isWasmInitialized) {
20221 throw new Error("initializeWasm() must be awaited first!");
20223 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
20224 return nativeResponseValue;
20226 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
20228 export function LightningError_clone(orig: number): number {
20229 if(!isWasmInitialized) {
20230 throw new Error("initializeWasm() must be awaited first!");
20232 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
20233 return nativeResponseValue;
20235 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
20237 export function CommitmentUpdate_free(this_obj: number): void {
20238 if(!isWasmInitialized) {
20239 throw new Error("initializeWasm() must be awaited first!");
20241 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
20242 // debug statements here
20244 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20246 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
20247 if(!isWasmInitialized) {
20248 throw new Error("initializeWasm() must be awaited first!");
20250 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
20251 return nativeResponseValue;
20253 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
20255 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
20256 if(!isWasmInitialized) {
20257 throw new Error("initializeWasm() must be awaited first!");
20259 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
20260 // debug statements here
20262 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20264 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
20265 if(!isWasmInitialized) {
20266 throw new Error("initializeWasm() must be awaited first!");
20268 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
20269 return nativeResponseValue;
20271 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
20273 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
20274 if(!isWasmInitialized) {
20275 throw new Error("initializeWasm() must be awaited first!");
20277 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
20278 // debug statements here
20280 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20282 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
20283 if(!isWasmInitialized) {
20284 throw new Error("initializeWasm() must be awaited first!");
20286 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
20287 return nativeResponseValue;
20289 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
20291 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
20292 if(!isWasmInitialized) {
20293 throw new Error("initializeWasm() must be awaited first!");
20295 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
20296 // debug statements here
20298 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20300 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
20301 if(!isWasmInitialized) {
20302 throw new Error("initializeWasm() must be awaited first!");
20304 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
20305 return nativeResponseValue;
20307 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
20309 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
20310 if(!isWasmInitialized) {
20311 throw new Error("initializeWasm() must be awaited first!");
20313 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
20314 // debug statements here
20316 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20318 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
20319 if(!isWasmInitialized) {
20320 throw new Error("initializeWasm() must be awaited first!");
20322 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
20323 return nativeResponseValue;
20325 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
20327 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
20328 if(!isWasmInitialized) {
20329 throw new Error("initializeWasm() must be awaited first!");
20331 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
20332 // debug statements here
20334 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20336 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
20337 if(!isWasmInitialized) {
20338 throw new Error("initializeWasm() must be awaited first!");
20340 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
20341 return nativeResponseValue;
20343 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
20345 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
20346 if(!isWasmInitialized) {
20347 throw new Error("initializeWasm() must be awaited first!");
20349 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
20350 // debug statements here
20352 // 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);
20354 export function CommitmentUpdate_new(update_add_htlcs_arg: number, update_fulfill_htlcs_arg: number, update_fail_htlcs_arg: number, update_fail_malformed_htlcs_arg: number, update_fee_arg: number, commitment_signed_arg: number): number {
20355 if(!isWasmInitialized) {
20356 throw new Error("initializeWasm() must be awaited first!");
20358 const nativeResponseValue = wasm.TS_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);
20359 return nativeResponseValue;
20361 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
20363 export function CommitmentUpdate_clone_ptr(arg: number): number {
20364 if(!isWasmInitialized) {
20365 throw new Error("initializeWasm() must be awaited first!");
20367 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
20368 return nativeResponseValue;
20370 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
20372 export function CommitmentUpdate_clone(orig: number): number {
20373 if(!isWasmInitialized) {
20374 throw new Error("initializeWasm() must be awaited first!");
20376 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
20377 return nativeResponseValue;
20379 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
20381 export function ChannelMessageHandler_free(this_ptr: number): void {
20382 if(!isWasmInitialized) {
20383 throw new Error("initializeWasm() must be awaited first!");
20385 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
20386 // debug statements here
20388 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
20390 export function RoutingMessageHandler_free(this_ptr: number): void {
20391 if(!isWasmInitialized) {
20392 throw new Error("initializeWasm() must be awaited first!");
20394 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
20395 // debug statements here
20397 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
20399 export function AcceptChannel_write(obj: number): number {
20400 if(!isWasmInitialized) {
20401 throw new Error("initializeWasm() must be awaited first!");
20403 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
20404 return nativeResponseValue;
20406 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
20408 export function AcceptChannel_read(ser: number): number {
20409 if(!isWasmInitialized) {
20410 throw new Error("initializeWasm() must be awaited first!");
20412 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
20413 return nativeResponseValue;
20415 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
20417 export function AnnouncementSignatures_write(obj: number): number {
20418 if(!isWasmInitialized) {
20419 throw new Error("initializeWasm() must be awaited first!");
20421 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
20422 return nativeResponseValue;
20424 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
20426 export function AnnouncementSignatures_read(ser: number): number {
20427 if(!isWasmInitialized) {
20428 throw new Error("initializeWasm() must be awaited first!");
20430 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
20431 return nativeResponseValue;
20433 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
20435 export function ChannelReestablish_write(obj: number): number {
20436 if(!isWasmInitialized) {
20437 throw new Error("initializeWasm() must be awaited first!");
20439 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
20440 return nativeResponseValue;
20442 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
20444 export function ChannelReestablish_read(ser: number): number {
20445 if(!isWasmInitialized) {
20446 throw new Error("initializeWasm() must be awaited first!");
20448 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
20449 return nativeResponseValue;
20451 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
20453 export function ClosingSigned_write(obj: number): number {
20454 if(!isWasmInitialized) {
20455 throw new Error("initializeWasm() must be awaited first!");
20457 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
20458 return nativeResponseValue;
20460 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
20462 export function ClosingSigned_read(ser: number): number {
20463 if(!isWasmInitialized) {
20464 throw new Error("initializeWasm() must be awaited first!");
20466 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
20467 return nativeResponseValue;
20469 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
20471 export function ClosingSignedFeeRange_write(obj: number): number {
20472 if(!isWasmInitialized) {
20473 throw new Error("initializeWasm() must be awaited first!");
20475 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
20476 return nativeResponseValue;
20478 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
20480 export function ClosingSignedFeeRange_read(ser: number): number {
20481 if(!isWasmInitialized) {
20482 throw new Error("initializeWasm() must be awaited first!");
20484 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
20485 return nativeResponseValue;
20487 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
20489 export function CommitmentSigned_write(obj: number): number {
20490 if(!isWasmInitialized) {
20491 throw new Error("initializeWasm() must be awaited first!");
20493 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
20494 return nativeResponseValue;
20496 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
20498 export function CommitmentSigned_read(ser: number): number {
20499 if(!isWasmInitialized) {
20500 throw new Error("initializeWasm() must be awaited first!");
20502 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
20503 return nativeResponseValue;
20505 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
20507 export function FundingCreated_write(obj: number): number {
20508 if(!isWasmInitialized) {
20509 throw new Error("initializeWasm() must be awaited first!");
20511 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
20512 return nativeResponseValue;
20514 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
20516 export function FundingCreated_read(ser: number): number {
20517 if(!isWasmInitialized) {
20518 throw new Error("initializeWasm() must be awaited first!");
20520 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
20521 return nativeResponseValue;
20523 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
20525 export function FundingSigned_write(obj: number): number {
20526 if(!isWasmInitialized) {
20527 throw new Error("initializeWasm() must be awaited first!");
20529 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
20530 return nativeResponseValue;
20532 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
20534 export function FundingSigned_read(ser: number): number {
20535 if(!isWasmInitialized) {
20536 throw new Error("initializeWasm() must be awaited first!");
20538 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
20539 return nativeResponseValue;
20541 // struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
20543 export function FundingLocked_write(obj: number): number {
20544 if(!isWasmInitialized) {
20545 throw new Error("initializeWasm() must be awaited first!");
20547 const nativeResponseValue = wasm.TS_FundingLocked_write(obj);
20548 return nativeResponseValue;
20550 // struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
20552 export function FundingLocked_read(ser: number): number {
20553 if(!isWasmInitialized) {
20554 throw new Error("initializeWasm() must be awaited first!");
20556 const nativeResponseValue = wasm.TS_FundingLocked_read(ser);
20557 return nativeResponseValue;
20559 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
20561 export function Init_write(obj: number): number {
20562 if(!isWasmInitialized) {
20563 throw new Error("initializeWasm() must be awaited first!");
20565 const nativeResponseValue = wasm.TS_Init_write(obj);
20566 return nativeResponseValue;
20568 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
20570 export function Init_read(ser: number): number {
20571 if(!isWasmInitialized) {
20572 throw new Error("initializeWasm() must be awaited first!");
20574 const nativeResponseValue = wasm.TS_Init_read(ser);
20575 return nativeResponseValue;
20577 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
20579 export function OpenChannel_write(obj: number): number {
20580 if(!isWasmInitialized) {
20581 throw new Error("initializeWasm() must be awaited first!");
20583 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
20584 return nativeResponseValue;
20586 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
20588 export function OpenChannel_read(ser: number): number {
20589 if(!isWasmInitialized) {
20590 throw new Error("initializeWasm() must be awaited first!");
20592 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
20593 return nativeResponseValue;
20595 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
20597 export function RevokeAndACK_write(obj: number): number {
20598 if(!isWasmInitialized) {
20599 throw new Error("initializeWasm() must be awaited first!");
20601 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
20602 return nativeResponseValue;
20604 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
20606 export function RevokeAndACK_read(ser: number): number {
20607 if(!isWasmInitialized) {
20608 throw new Error("initializeWasm() must be awaited first!");
20610 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
20611 return nativeResponseValue;
20613 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
20615 export function Shutdown_write(obj: number): number {
20616 if(!isWasmInitialized) {
20617 throw new Error("initializeWasm() must be awaited first!");
20619 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
20620 return nativeResponseValue;
20622 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
20624 export function Shutdown_read(ser: number): number {
20625 if(!isWasmInitialized) {
20626 throw new Error("initializeWasm() must be awaited first!");
20628 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
20629 return nativeResponseValue;
20631 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
20633 export function UpdateFailHTLC_write(obj: number): number {
20634 if(!isWasmInitialized) {
20635 throw new Error("initializeWasm() must be awaited first!");
20637 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
20638 return nativeResponseValue;
20640 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
20642 export function UpdateFailHTLC_read(ser: number): number {
20643 if(!isWasmInitialized) {
20644 throw new Error("initializeWasm() must be awaited first!");
20646 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
20647 return nativeResponseValue;
20649 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
20651 export function UpdateFailMalformedHTLC_write(obj: number): number {
20652 if(!isWasmInitialized) {
20653 throw new Error("initializeWasm() must be awaited first!");
20655 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
20656 return nativeResponseValue;
20658 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
20660 export function UpdateFailMalformedHTLC_read(ser: number): number {
20661 if(!isWasmInitialized) {
20662 throw new Error("initializeWasm() must be awaited first!");
20664 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
20665 return nativeResponseValue;
20667 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
20669 export function UpdateFee_write(obj: number): number {
20670 if(!isWasmInitialized) {
20671 throw new Error("initializeWasm() must be awaited first!");
20673 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
20674 return nativeResponseValue;
20676 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
20678 export function UpdateFee_read(ser: number): number {
20679 if(!isWasmInitialized) {
20680 throw new Error("initializeWasm() must be awaited first!");
20682 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
20683 return nativeResponseValue;
20685 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
20687 export function UpdateFulfillHTLC_write(obj: number): number {
20688 if(!isWasmInitialized) {
20689 throw new Error("initializeWasm() must be awaited first!");
20691 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
20692 return nativeResponseValue;
20694 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
20696 export function UpdateFulfillHTLC_read(ser: number): number {
20697 if(!isWasmInitialized) {
20698 throw new Error("initializeWasm() must be awaited first!");
20700 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
20701 return nativeResponseValue;
20703 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
20705 export function UpdateAddHTLC_write(obj: number): number {
20706 if(!isWasmInitialized) {
20707 throw new Error("initializeWasm() must be awaited first!");
20709 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
20710 return nativeResponseValue;
20712 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
20714 export function UpdateAddHTLC_read(ser: number): number {
20715 if(!isWasmInitialized) {
20716 throw new Error("initializeWasm() must be awaited first!");
20718 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
20719 return nativeResponseValue;
20721 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
20723 export function Ping_write(obj: number): number {
20724 if(!isWasmInitialized) {
20725 throw new Error("initializeWasm() must be awaited first!");
20727 const nativeResponseValue = wasm.TS_Ping_write(obj);
20728 return nativeResponseValue;
20730 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
20732 export function Ping_read(ser: number): number {
20733 if(!isWasmInitialized) {
20734 throw new Error("initializeWasm() must be awaited first!");
20736 const nativeResponseValue = wasm.TS_Ping_read(ser);
20737 return nativeResponseValue;
20739 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
20741 export function Pong_write(obj: number): number {
20742 if(!isWasmInitialized) {
20743 throw new Error("initializeWasm() must be awaited first!");
20745 const nativeResponseValue = wasm.TS_Pong_write(obj);
20746 return nativeResponseValue;
20748 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
20750 export function Pong_read(ser: number): number {
20751 if(!isWasmInitialized) {
20752 throw new Error("initializeWasm() must be awaited first!");
20754 const nativeResponseValue = wasm.TS_Pong_read(ser);
20755 return nativeResponseValue;
20757 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
20759 export function UnsignedChannelAnnouncement_write(obj: number): number {
20760 if(!isWasmInitialized) {
20761 throw new Error("initializeWasm() must be awaited first!");
20763 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
20764 return nativeResponseValue;
20766 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
20768 export function UnsignedChannelAnnouncement_read(ser: number): number {
20769 if(!isWasmInitialized) {
20770 throw new Error("initializeWasm() must be awaited first!");
20772 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
20773 return nativeResponseValue;
20775 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
20777 export function ChannelAnnouncement_write(obj: number): number {
20778 if(!isWasmInitialized) {
20779 throw new Error("initializeWasm() must be awaited first!");
20781 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
20782 return nativeResponseValue;
20784 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
20786 export function ChannelAnnouncement_read(ser: number): number {
20787 if(!isWasmInitialized) {
20788 throw new Error("initializeWasm() must be awaited first!");
20790 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
20791 return nativeResponseValue;
20793 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
20795 export function UnsignedChannelUpdate_write(obj: number): number {
20796 if(!isWasmInitialized) {
20797 throw new Error("initializeWasm() must be awaited first!");
20799 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
20800 return nativeResponseValue;
20802 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
20804 export function UnsignedChannelUpdate_read(ser: number): number {
20805 if(!isWasmInitialized) {
20806 throw new Error("initializeWasm() must be awaited first!");
20808 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
20809 return nativeResponseValue;
20811 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
20813 export function ChannelUpdate_write(obj: number): number {
20814 if(!isWasmInitialized) {
20815 throw new Error("initializeWasm() must be awaited first!");
20817 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
20818 return nativeResponseValue;
20820 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
20822 export function ChannelUpdate_read(ser: number): number {
20823 if(!isWasmInitialized) {
20824 throw new Error("initializeWasm() must be awaited first!");
20826 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
20827 return nativeResponseValue;
20829 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
20831 export function ErrorMessage_write(obj: number): number {
20832 if(!isWasmInitialized) {
20833 throw new Error("initializeWasm() must be awaited first!");
20835 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
20836 return nativeResponseValue;
20838 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
20840 export function ErrorMessage_read(ser: number): number {
20841 if(!isWasmInitialized) {
20842 throw new Error("initializeWasm() must be awaited first!");
20844 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
20845 return nativeResponseValue;
20847 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
20849 export function UnsignedNodeAnnouncement_write(obj: number): number {
20850 if(!isWasmInitialized) {
20851 throw new Error("initializeWasm() must be awaited first!");
20853 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
20854 return nativeResponseValue;
20856 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
20858 export function UnsignedNodeAnnouncement_read(ser: number): number {
20859 if(!isWasmInitialized) {
20860 throw new Error("initializeWasm() must be awaited first!");
20862 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
20863 return nativeResponseValue;
20865 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
20867 export function NodeAnnouncement_write(obj: number): number {
20868 if(!isWasmInitialized) {
20869 throw new Error("initializeWasm() must be awaited first!");
20871 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
20872 return nativeResponseValue;
20874 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
20876 export function NodeAnnouncement_read(ser: number): number {
20877 if(!isWasmInitialized) {
20878 throw new Error("initializeWasm() must be awaited first!");
20880 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
20881 return nativeResponseValue;
20883 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
20885 export function QueryShortChannelIds_read(ser: number): number {
20886 if(!isWasmInitialized) {
20887 throw new Error("initializeWasm() must be awaited first!");
20889 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
20890 return nativeResponseValue;
20892 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
20894 export function QueryShortChannelIds_write(obj: number): number {
20895 if(!isWasmInitialized) {
20896 throw new Error("initializeWasm() must be awaited first!");
20898 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
20899 return nativeResponseValue;
20901 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
20903 export function ReplyShortChannelIdsEnd_write(obj: number): number {
20904 if(!isWasmInitialized) {
20905 throw new Error("initializeWasm() must be awaited first!");
20907 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
20908 return nativeResponseValue;
20910 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
20912 export function ReplyShortChannelIdsEnd_read(ser: number): number {
20913 if(!isWasmInitialized) {
20914 throw new Error("initializeWasm() must be awaited first!");
20916 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
20917 return nativeResponseValue;
20919 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
20921 export function QueryChannelRange_end_blocknum(this_arg: number): number {
20922 if(!isWasmInitialized) {
20923 throw new Error("initializeWasm() must be awaited first!");
20925 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
20926 return nativeResponseValue;
20928 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
20930 export function QueryChannelRange_write(obj: number): number {
20931 if(!isWasmInitialized) {
20932 throw new Error("initializeWasm() must be awaited first!");
20934 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
20935 return nativeResponseValue;
20937 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
20939 export function QueryChannelRange_read(ser: number): number {
20940 if(!isWasmInitialized) {
20941 throw new Error("initializeWasm() must be awaited first!");
20943 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
20944 return nativeResponseValue;
20946 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
20948 export function ReplyChannelRange_read(ser: number): number {
20949 if(!isWasmInitialized) {
20950 throw new Error("initializeWasm() must be awaited first!");
20952 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
20953 return nativeResponseValue;
20955 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
20957 export function ReplyChannelRange_write(obj: number): number {
20958 if(!isWasmInitialized) {
20959 throw new Error("initializeWasm() must be awaited first!");
20961 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
20962 return nativeResponseValue;
20964 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
20966 export function GossipTimestampFilter_write(obj: number): number {
20967 if(!isWasmInitialized) {
20968 throw new Error("initializeWasm() must be awaited first!");
20970 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
20971 return nativeResponseValue;
20973 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
20975 export function GossipTimestampFilter_read(ser: number): number {
20976 if(!isWasmInitialized) {
20977 throw new Error("initializeWasm() must be awaited first!");
20979 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
20980 return nativeResponseValue;
20982 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
20984 export function CustomMessageHandler_free(this_ptr: number): void {
20985 if(!isWasmInitialized) {
20986 throw new Error("initializeWasm() must be awaited first!");
20988 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
20989 // debug statements here
20991 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
20993 export function IgnoringMessageHandler_free(this_obj: number): void {
20994 if(!isWasmInitialized) {
20995 throw new Error("initializeWasm() must be awaited first!");
20997 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
20998 // debug statements here
21000 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
21002 export function IgnoringMessageHandler_new(): number {
21003 if(!isWasmInitialized) {
21004 throw new Error("initializeWasm() must be awaited first!");
21006 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
21007 return nativeResponseValue;
21009 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21011 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
21012 if(!isWasmInitialized) {
21013 throw new Error("initializeWasm() must be awaited first!");
21015 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
21016 return nativeResponseValue;
21018 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21020 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
21021 if(!isWasmInitialized) {
21022 throw new Error("initializeWasm() must be awaited first!");
21024 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
21025 return nativeResponseValue;
21027 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21029 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
21030 if(!isWasmInitialized) {
21031 throw new Error("initializeWasm() must be awaited first!");
21033 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
21034 return nativeResponseValue;
21036 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21038 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
21039 if(!isWasmInitialized) {
21040 throw new Error("initializeWasm() must be awaited first!");
21042 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
21043 return nativeResponseValue;
21045 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
21047 export function ErroringMessageHandler_free(this_obj: number): void {
21048 if(!isWasmInitialized) {
21049 throw new Error("initializeWasm() must be awaited first!");
21051 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
21052 // debug statements here
21054 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
21056 export function ErroringMessageHandler_new(): number {
21057 if(!isWasmInitialized) {
21058 throw new Error("initializeWasm() must be awaited first!");
21060 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
21061 return nativeResponseValue;
21063 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
21065 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
21066 if(!isWasmInitialized) {
21067 throw new Error("initializeWasm() must be awaited first!");
21069 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
21070 return nativeResponseValue;
21072 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
21074 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
21075 if(!isWasmInitialized) {
21076 throw new Error("initializeWasm() must be awaited first!");
21078 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
21079 return nativeResponseValue;
21081 // void MessageHandler_free(struct LDKMessageHandler this_obj);
21083 export function MessageHandler_free(this_obj: number): void {
21084 if(!isWasmInitialized) {
21085 throw new Error("initializeWasm() must be awaited first!");
21087 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
21088 // debug statements here
21090 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
21092 export function MessageHandler_get_chan_handler(this_ptr: number): number {
21093 if(!isWasmInitialized) {
21094 throw new Error("initializeWasm() must be awaited first!");
21096 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
21097 return nativeResponseValue;
21099 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
21101 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
21102 if(!isWasmInitialized) {
21103 throw new Error("initializeWasm() must be awaited first!");
21105 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
21106 // debug statements here
21108 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
21110 export function MessageHandler_get_route_handler(this_ptr: number): number {
21111 if(!isWasmInitialized) {
21112 throw new Error("initializeWasm() must be awaited first!");
21114 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
21115 return nativeResponseValue;
21117 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
21119 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
21120 if(!isWasmInitialized) {
21121 throw new Error("initializeWasm() must be awaited first!");
21123 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
21124 // debug statements here
21126 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
21128 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
21129 if(!isWasmInitialized) {
21130 throw new Error("initializeWasm() must be awaited first!");
21132 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
21133 return nativeResponseValue;
21135 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
21137 export function SocketDescriptor_clone_ptr(arg: number): number {
21138 if(!isWasmInitialized) {
21139 throw new Error("initializeWasm() must be awaited first!");
21141 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
21142 return nativeResponseValue;
21144 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
21146 export function SocketDescriptor_clone(orig: number): number {
21147 if(!isWasmInitialized) {
21148 throw new Error("initializeWasm() must be awaited first!");
21150 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
21151 return nativeResponseValue;
21153 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
21155 export function SocketDescriptor_free(this_ptr: number): void {
21156 if(!isWasmInitialized) {
21157 throw new Error("initializeWasm() must be awaited first!");
21159 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
21160 // debug statements here
21162 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
21164 export function PeerHandleError_free(this_obj: number): void {
21165 if(!isWasmInitialized) {
21166 throw new Error("initializeWasm() must be awaited first!");
21168 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
21169 // debug statements here
21171 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
21173 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
21174 if(!isWasmInitialized) {
21175 throw new Error("initializeWasm() must be awaited first!");
21177 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
21178 return nativeResponseValue;
21180 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
21182 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
21183 if(!isWasmInitialized) {
21184 throw new Error("initializeWasm() must be awaited first!");
21186 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
21187 // debug statements here
21189 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
21191 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
21192 if(!isWasmInitialized) {
21193 throw new Error("initializeWasm() must be awaited first!");
21195 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
21196 return nativeResponseValue;
21198 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
21200 export function PeerHandleError_clone_ptr(arg: number): number {
21201 if(!isWasmInitialized) {
21202 throw new Error("initializeWasm() must be awaited first!");
21204 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
21205 return nativeResponseValue;
21207 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
21209 export function PeerHandleError_clone(orig: number): number {
21210 if(!isWasmInitialized) {
21211 throw new Error("initializeWasm() must be awaited first!");
21213 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
21214 return nativeResponseValue;
21216 // void PeerManager_free(struct LDKPeerManager this_obj);
21218 export function PeerManager_free(this_obj: number): void {
21219 if(!isWasmInitialized) {
21220 throw new Error("initializeWasm() must be awaited first!");
21222 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
21223 // debug statements here
21225 // MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger, struct LDKCustomMessageHandler custom_message_handler);
21227 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
21228 if(!isWasmInitialized) {
21229 throw new Error("initializeWasm() must be awaited first!");
21231 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
21232 return nativeResponseValue;
21234 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
21236 export function PeerManager_get_peer_node_ids(this_arg: number): number {
21237 if(!isWasmInitialized) {
21238 throw new Error("initializeWasm() must be awaited first!");
21240 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
21241 return nativeResponseValue;
21243 // MUST_USE_RES struct LDKCResult_CVec_u8ZPeerHandleErrorZ PeerManager_new_outbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKSocketDescriptor descriptor);
21245 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number): number {
21246 if(!isWasmInitialized) {
21247 throw new Error("initializeWasm() must be awaited first!");
21249 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor);
21250 return nativeResponseValue;
21252 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor);
21254 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number): number {
21255 if(!isWasmInitialized) {
21256 throw new Error("initializeWasm() must be awaited first!");
21258 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor);
21259 return nativeResponseValue;
21261 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
21263 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
21264 if(!isWasmInitialized) {
21265 throw new Error("initializeWasm() must be awaited first!");
21267 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
21268 return nativeResponseValue;
21270 // MUST_USE_RES struct LDKCResult_boolPeerHandleErrorZ PeerManager_read_event(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR peer_descriptor, struct LDKu8slice data);
21272 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
21273 if(!isWasmInitialized) {
21274 throw new Error("initializeWasm() must be awaited first!");
21276 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
21277 return nativeResponseValue;
21279 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
21281 export function PeerManager_process_events(this_arg: number): void {
21282 if(!isWasmInitialized) {
21283 throw new Error("initializeWasm() must be awaited first!");
21285 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
21286 // debug statements here
21288 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
21290 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
21291 if(!isWasmInitialized) {
21292 throw new Error("initializeWasm() must be awaited first!");
21294 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
21295 // debug statements here
21297 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
21299 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
21300 if(!isWasmInitialized) {
21301 throw new Error("initializeWasm() must be awaited first!");
21303 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
21304 // debug statements here
21306 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
21308 export function PeerManager_disconnect_all_peers(this_arg: number): void {
21309 if(!isWasmInitialized) {
21310 throw new Error("initializeWasm() must be awaited first!");
21312 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
21313 // debug statements here
21315 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
21317 export function PeerManager_timer_tick_occurred(this_arg: number): void {
21318 if(!isWasmInitialized) {
21319 throw new Error("initializeWasm() must be awaited first!");
21321 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
21322 // debug statements here
21324 // uint64_t htlc_success_tx_weight(bool opt_anchors);
21326 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
21327 if(!isWasmInitialized) {
21328 throw new Error("initializeWasm() must be awaited first!");
21330 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
21331 return nativeResponseValue;
21333 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
21335 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
21336 if(!isWasmInitialized) {
21337 throw new Error("initializeWasm() must be awaited first!");
21339 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
21340 return nativeResponseValue;
21342 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
21344 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
21345 if(!isWasmInitialized) {
21346 throw new Error("initializeWasm() must be awaited first!");
21348 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
21349 return nativeResponseValue;
21351 // struct LDKTransaction build_closing_transaction(uint64_t to_holder_value_sat, uint64_t to_counterparty_value_sat, struct LDKCVec_u8Z to_holder_script, struct LDKCVec_u8Z to_counterparty_script, struct LDKOutPoint funding_outpoint);
21353 export function build_closing_transaction(to_holder_value_sat: bigint, to_counterparty_value_sat: bigint, to_holder_script: number, to_counterparty_script: number, funding_outpoint: number): number {
21354 if(!isWasmInitialized) {
21355 throw new Error("initializeWasm() must be awaited first!");
21357 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
21358 return nativeResponseValue;
21360 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
21362 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
21363 if(!isWasmInitialized) {
21364 throw new Error("initializeWasm() must be awaited first!");
21366 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
21367 return nativeResponseValue;
21369 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
21371 export function derive_public_key(per_commitment_point: number, base_point: number): number {
21372 if(!isWasmInitialized) {
21373 throw new Error("initializeWasm() must be awaited first!");
21375 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
21376 return nativeResponseValue;
21378 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
21380 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
21381 if(!isWasmInitialized) {
21382 throw new Error("initializeWasm() must be awaited first!");
21384 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
21385 return nativeResponseValue;
21387 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
21389 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
21390 if(!isWasmInitialized) {
21391 throw new Error("initializeWasm() must be awaited first!");
21393 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
21394 return nativeResponseValue;
21396 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
21398 export function TxCreationKeys_free(this_obj: number): void {
21399 if(!isWasmInitialized) {
21400 throw new Error("initializeWasm() must be awaited first!");
21402 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
21403 // debug statements here
21405 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21407 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
21408 if(!isWasmInitialized) {
21409 throw new Error("initializeWasm() must be awaited first!");
21411 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
21412 return nativeResponseValue;
21414 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21416 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
21417 if(!isWasmInitialized) {
21418 throw new Error("initializeWasm() must be awaited first!");
21420 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
21421 // debug statements here
21423 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21425 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
21426 if(!isWasmInitialized) {
21427 throw new Error("initializeWasm() must be awaited first!");
21429 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
21430 return nativeResponseValue;
21432 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21434 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
21435 if(!isWasmInitialized) {
21436 throw new Error("initializeWasm() must be awaited first!");
21438 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
21439 // debug statements here
21441 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21443 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
21444 if(!isWasmInitialized) {
21445 throw new Error("initializeWasm() must be awaited first!");
21447 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
21448 return nativeResponseValue;
21450 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21452 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
21453 if(!isWasmInitialized) {
21454 throw new Error("initializeWasm() must be awaited first!");
21456 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
21457 // debug statements here
21459 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21461 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
21462 if(!isWasmInitialized) {
21463 throw new Error("initializeWasm() must be awaited first!");
21465 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
21466 return nativeResponseValue;
21468 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21470 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
21471 if(!isWasmInitialized) {
21472 throw new Error("initializeWasm() must be awaited first!");
21474 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
21475 // debug statements here
21477 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21479 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
21480 if(!isWasmInitialized) {
21481 throw new Error("initializeWasm() must be awaited first!");
21483 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
21484 return nativeResponseValue;
21486 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21488 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
21489 if(!isWasmInitialized) {
21490 throw new Error("initializeWasm() must be awaited first!");
21492 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
21493 // debug statements here
21495 // 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);
21497 export function TxCreationKeys_new(per_commitment_point_arg: number, revocation_key_arg: number, broadcaster_htlc_key_arg: number, countersignatory_htlc_key_arg: number, broadcaster_delayed_payment_key_arg: number): number {
21498 if(!isWasmInitialized) {
21499 throw new Error("initializeWasm() must be awaited first!");
21501 const nativeResponseValue = wasm.TS_TxCreationKeys_new(per_commitment_point_arg, revocation_key_arg, broadcaster_htlc_key_arg, countersignatory_htlc_key_arg, broadcaster_delayed_payment_key_arg);
21502 return nativeResponseValue;
21504 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
21506 export function TxCreationKeys_clone_ptr(arg: number): number {
21507 if(!isWasmInitialized) {
21508 throw new Error("initializeWasm() must be awaited first!");
21510 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
21511 return nativeResponseValue;
21513 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
21515 export function TxCreationKeys_clone(orig: number): number {
21516 if(!isWasmInitialized) {
21517 throw new Error("initializeWasm() must be awaited first!");
21519 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
21520 return nativeResponseValue;
21522 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
21524 export function TxCreationKeys_write(obj: number): number {
21525 if(!isWasmInitialized) {
21526 throw new Error("initializeWasm() must be awaited first!");
21528 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
21529 return nativeResponseValue;
21531 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
21533 export function TxCreationKeys_read(ser: number): number {
21534 if(!isWasmInitialized) {
21535 throw new Error("initializeWasm() must be awaited first!");
21537 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
21538 return nativeResponseValue;
21540 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
21542 export function ChannelPublicKeys_free(this_obj: number): void {
21543 if(!isWasmInitialized) {
21544 throw new Error("initializeWasm() must be awaited first!");
21546 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
21547 // debug statements here
21549 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21551 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
21552 if(!isWasmInitialized) {
21553 throw new Error("initializeWasm() must be awaited first!");
21555 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
21556 return nativeResponseValue;
21558 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21560 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
21561 if(!isWasmInitialized) {
21562 throw new Error("initializeWasm() must be awaited first!");
21564 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
21565 // debug statements here
21567 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21569 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
21570 if(!isWasmInitialized) {
21571 throw new Error("initializeWasm() must be awaited first!");
21573 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
21574 return nativeResponseValue;
21576 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21578 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
21579 if(!isWasmInitialized) {
21580 throw new Error("initializeWasm() must be awaited first!");
21582 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
21583 // debug statements here
21585 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21587 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
21588 if(!isWasmInitialized) {
21589 throw new Error("initializeWasm() must be awaited first!");
21591 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
21592 return nativeResponseValue;
21594 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21596 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
21597 if(!isWasmInitialized) {
21598 throw new Error("initializeWasm() must be awaited first!");
21600 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
21601 // debug statements here
21603 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21605 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
21606 if(!isWasmInitialized) {
21607 throw new Error("initializeWasm() must be awaited first!");
21609 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
21610 return nativeResponseValue;
21612 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21614 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21615 if(!isWasmInitialized) {
21616 throw new Error("initializeWasm() must be awaited first!");
21618 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
21619 // debug statements here
21621 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21623 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
21624 if(!isWasmInitialized) {
21625 throw new Error("initializeWasm() must be awaited first!");
21627 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
21628 return nativeResponseValue;
21630 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21632 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
21633 if(!isWasmInitialized) {
21634 throw new Error("initializeWasm() must be awaited first!");
21636 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
21637 // debug statements here
21639 // 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);
21641 export function ChannelPublicKeys_new(funding_pubkey_arg: number, revocation_basepoint_arg: number, payment_point_arg: number, delayed_payment_basepoint_arg: number, htlc_basepoint_arg: number): number {
21642 if(!isWasmInitialized) {
21643 throw new Error("initializeWasm() must be awaited first!");
21645 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
21646 return nativeResponseValue;
21648 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
21650 export function ChannelPublicKeys_clone_ptr(arg: number): number {
21651 if(!isWasmInitialized) {
21652 throw new Error("initializeWasm() must be awaited first!");
21654 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
21655 return nativeResponseValue;
21657 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
21659 export function ChannelPublicKeys_clone(orig: number): number {
21660 if(!isWasmInitialized) {
21661 throw new Error("initializeWasm() must be awaited first!");
21663 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
21664 return nativeResponseValue;
21666 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
21668 export function ChannelPublicKeys_write(obj: number): number {
21669 if(!isWasmInitialized) {
21670 throw new Error("initializeWasm() must be awaited first!");
21672 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
21673 return nativeResponseValue;
21675 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
21677 export function ChannelPublicKeys_read(ser: number): number {
21678 if(!isWasmInitialized) {
21679 throw new Error("initializeWasm() must be awaited first!");
21681 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
21682 return nativeResponseValue;
21684 // MUST_USE_RES struct LDKCResult_TxCreationKeysErrorZ TxCreationKeys_derive_new(struct LDKPublicKey per_commitment_point, struct LDKPublicKey broadcaster_delayed_payment_base, struct LDKPublicKey broadcaster_htlc_base, struct LDKPublicKey countersignatory_revocation_base, struct LDKPublicKey countersignatory_htlc_base);
21686 export function TxCreationKeys_derive_new(per_commitment_point: number, broadcaster_delayed_payment_base: number, broadcaster_htlc_base: number, countersignatory_revocation_base: number, countersignatory_htlc_base: number): number {
21687 if(!isWasmInitialized) {
21688 throw new Error("initializeWasm() must be awaited first!");
21690 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
21691 return nativeResponseValue;
21693 // MUST_USE_RES struct LDKCResult_TxCreationKeysErrorZ TxCreationKeys_from_channel_static_keys(struct LDKPublicKey per_commitment_point, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
21695 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
21696 if(!isWasmInitialized) {
21697 throw new Error("initializeWasm() must be awaited first!");
21699 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
21700 return nativeResponseValue;
21702 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
21704 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
21705 if(!isWasmInitialized) {
21706 throw new Error("initializeWasm() must be awaited first!");
21708 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
21709 return nativeResponseValue;
21711 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
21713 export function HTLCOutputInCommitment_free(this_obj: number): void {
21714 if(!isWasmInitialized) {
21715 throw new Error("initializeWasm() must be awaited first!");
21717 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
21718 // debug statements here
21720 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21722 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
21723 if(!isWasmInitialized) {
21724 throw new Error("initializeWasm() must be awaited first!");
21726 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
21727 return nativeResponseValue;
21729 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
21731 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
21732 if(!isWasmInitialized) {
21733 throw new Error("initializeWasm() must be awaited first!");
21735 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
21736 // debug statements here
21738 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21740 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
21741 if(!isWasmInitialized) {
21742 throw new Error("initializeWasm() must be awaited first!");
21744 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
21745 return nativeResponseValue;
21747 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
21749 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
21750 if(!isWasmInitialized) {
21751 throw new Error("initializeWasm() must be awaited first!");
21753 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
21754 // debug statements here
21756 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21758 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
21759 if(!isWasmInitialized) {
21760 throw new Error("initializeWasm() must be awaited first!");
21762 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
21763 return nativeResponseValue;
21765 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
21767 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
21768 if(!isWasmInitialized) {
21769 throw new Error("initializeWasm() must be awaited first!");
21771 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
21772 // debug statements here
21774 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
21776 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
21777 if(!isWasmInitialized) {
21778 throw new Error("initializeWasm() must be awaited first!");
21780 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
21781 return nativeResponseValue;
21783 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21785 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
21786 if(!isWasmInitialized) {
21787 throw new Error("initializeWasm() must be awaited first!");
21789 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
21790 // debug statements here
21792 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21794 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
21795 if(!isWasmInitialized) {
21796 throw new Error("initializeWasm() must be awaited first!");
21798 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
21799 return nativeResponseValue;
21801 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
21803 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
21804 if(!isWasmInitialized) {
21805 throw new Error("initializeWasm() must be awaited first!");
21807 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
21808 // debug statements here
21810 // 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);
21812 export function HTLCOutputInCommitment_new(offered_arg: boolean, amount_msat_arg: bigint, cltv_expiry_arg: number, payment_hash_arg: number, transaction_output_index_arg: number): number {
21813 if(!isWasmInitialized) {
21814 throw new Error("initializeWasm() must be awaited first!");
21816 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
21817 return nativeResponseValue;
21819 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
21821 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
21822 if(!isWasmInitialized) {
21823 throw new Error("initializeWasm() must be awaited first!");
21825 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
21826 return nativeResponseValue;
21828 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
21830 export function HTLCOutputInCommitment_clone(orig: number): number {
21831 if(!isWasmInitialized) {
21832 throw new Error("initializeWasm() must be awaited first!");
21834 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
21835 return nativeResponseValue;
21837 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
21839 export function HTLCOutputInCommitment_write(obj: number): number {
21840 if(!isWasmInitialized) {
21841 throw new Error("initializeWasm() must be awaited first!");
21843 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
21844 return nativeResponseValue;
21846 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
21848 export function HTLCOutputInCommitment_read(ser: number): number {
21849 if(!isWasmInitialized) {
21850 throw new Error("initializeWasm() must be awaited first!");
21852 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
21853 return nativeResponseValue;
21855 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
21857 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
21858 if(!isWasmInitialized) {
21859 throw new Error("initializeWasm() must be awaited first!");
21861 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
21862 return nativeResponseValue;
21864 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
21866 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
21867 if(!isWasmInitialized) {
21868 throw new Error("initializeWasm() must be awaited first!");
21870 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
21871 return nativeResponseValue;
21873 // struct LDKTransaction build_htlc_transaction(const uint8_t (*commitment_txid)[32], uint32_t feerate_per_kw, uint16_t contest_delay, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, struct LDKPublicKey broadcaster_delayed_payment_key, struct LDKPublicKey revocation_key);
21875 export function build_htlc_transaction(commitment_txid: number, feerate_per_kw: number, contest_delay: number, htlc: number, opt_anchors: boolean, broadcaster_delayed_payment_key: number, revocation_key: number): number {
21876 if(!isWasmInitialized) {
21877 throw new Error("initializeWasm() must be awaited first!");
21879 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
21880 return nativeResponseValue;
21882 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
21884 export function get_anchor_redeemscript(funding_pubkey: number): number {
21885 if(!isWasmInitialized) {
21886 throw new Error("initializeWasm() must be awaited first!");
21888 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
21889 return nativeResponseValue;
21891 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
21893 export function ChannelTransactionParameters_free(this_obj: number): void {
21894 if(!isWasmInitialized) {
21895 throw new Error("initializeWasm() must be awaited first!");
21897 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
21898 // debug statements here
21900 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21902 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
21903 if(!isWasmInitialized) {
21904 throw new Error("initializeWasm() must be awaited first!");
21906 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
21907 return nativeResponseValue;
21909 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
21911 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
21912 if(!isWasmInitialized) {
21913 throw new Error("initializeWasm() must be awaited first!");
21915 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
21916 // debug statements here
21918 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21920 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
21921 if(!isWasmInitialized) {
21922 throw new Error("initializeWasm() must be awaited first!");
21924 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
21925 return nativeResponseValue;
21927 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
21929 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
21930 if(!isWasmInitialized) {
21931 throw new Error("initializeWasm() must be awaited first!");
21933 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
21934 // debug statements here
21936 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21938 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
21939 if(!isWasmInitialized) {
21940 throw new Error("initializeWasm() must be awaited first!");
21942 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
21943 return nativeResponseValue;
21945 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
21947 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
21948 if(!isWasmInitialized) {
21949 throw new Error("initializeWasm() must be awaited first!");
21951 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
21952 // debug statements here
21954 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21956 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
21957 if(!isWasmInitialized) {
21958 throw new Error("initializeWasm() must be awaited first!");
21960 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
21961 return nativeResponseValue;
21963 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
21965 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
21966 if(!isWasmInitialized) {
21967 throw new Error("initializeWasm() must be awaited first!");
21969 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
21970 // debug statements here
21972 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21974 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
21975 if(!isWasmInitialized) {
21976 throw new Error("initializeWasm() must be awaited first!");
21978 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
21979 return nativeResponseValue;
21981 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
21983 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
21984 if(!isWasmInitialized) {
21985 throw new Error("initializeWasm() must be awaited first!");
21987 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
21988 // debug statements here
21990 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21992 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
21993 if(!isWasmInitialized) {
21994 throw new Error("initializeWasm() must be awaited first!");
21996 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
21997 return nativeResponseValue;
21999 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
22001 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
22002 if(!isWasmInitialized) {
22003 throw new Error("initializeWasm() must be awaited first!");
22005 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
22006 // debug statements here
22008 // 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, enum LDKCOption_NoneZ opt_anchors_arg);
22010 export function ChannelTransactionParameters_new(holder_pubkeys_arg: number, holder_selected_contest_delay_arg: number, is_outbound_from_holder_arg: boolean, counterparty_parameters_arg: number, funding_outpoint_arg: number, opt_anchors_arg: COption_NoneZ): number {
22011 if(!isWasmInitialized) {
22012 throw new Error("initializeWasm() must be awaited first!");
22014 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_new(holder_pubkeys_arg, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg, funding_outpoint_arg, opt_anchors_arg);
22015 return nativeResponseValue;
22017 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
22019 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
22020 if(!isWasmInitialized) {
22021 throw new Error("initializeWasm() must be awaited first!");
22023 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
22024 return nativeResponseValue;
22026 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
22028 export function ChannelTransactionParameters_clone(orig: number): number {
22029 if(!isWasmInitialized) {
22030 throw new Error("initializeWasm() must be awaited first!");
22032 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
22033 return nativeResponseValue;
22035 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
22037 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
22038 if(!isWasmInitialized) {
22039 throw new Error("initializeWasm() must be awaited first!");
22041 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
22042 // debug statements here
22044 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
22046 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
22047 if(!isWasmInitialized) {
22048 throw new Error("initializeWasm() must be awaited first!");
22050 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
22051 return nativeResponseValue;
22053 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
22055 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
22056 if(!isWasmInitialized) {
22057 throw new Error("initializeWasm() must be awaited first!");
22059 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
22060 // debug statements here
22062 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
22064 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
22065 if(!isWasmInitialized) {
22066 throw new Error("initializeWasm() must be awaited first!");
22068 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
22069 return nativeResponseValue;
22071 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
22073 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
22074 if(!isWasmInitialized) {
22075 throw new Error("initializeWasm() must be awaited first!");
22077 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
22078 // debug statements here
22080 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
22082 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
22083 if(!isWasmInitialized) {
22084 throw new Error("initializeWasm() must be awaited first!");
22086 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
22087 return nativeResponseValue;
22089 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
22091 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
22092 if(!isWasmInitialized) {
22093 throw new Error("initializeWasm() must be awaited first!");
22095 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
22096 return nativeResponseValue;
22098 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
22100 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
22101 if(!isWasmInitialized) {
22102 throw new Error("initializeWasm() must be awaited first!");
22104 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
22105 return nativeResponseValue;
22107 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
22109 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
22110 if(!isWasmInitialized) {
22111 throw new Error("initializeWasm() must be awaited first!");
22113 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
22114 return nativeResponseValue;
22116 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
22118 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
22119 if(!isWasmInitialized) {
22120 throw new Error("initializeWasm() must be awaited first!");
22122 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
22123 return nativeResponseValue;
22125 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
22127 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
22128 if(!isWasmInitialized) {
22129 throw new Error("initializeWasm() must be awaited first!");
22131 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
22132 return nativeResponseValue;
22134 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
22136 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
22137 if(!isWasmInitialized) {
22138 throw new Error("initializeWasm() must be awaited first!");
22140 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
22141 return nativeResponseValue;
22143 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
22145 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
22146 if(!isWasmInitialized) {
22147 throw new Error("initializeWasm() must be awaited first!");
22149 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
22150 return nativeResponseValue;
22152 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
22154 export function ChannelTransactionParameters_write(obj: number): number {
22155 if(!isWasmInitialized) {
22156 throw new Error("initializeWasm() must be awaited first!");
22158 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
22159 return nativeResponseValue;
22161 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
22163 export function ChannelTransactionParameters_read(ser: number): number {
22164 if(!isWasmInitialized) {
22165 throw new Error("initializeWasm() must be awaited first!");
22167 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
22168 return nativeResponseValue;
22170 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
22172 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
22173 if(!isWasmInitialized) {
22174 throw new Error("initializeWasm() must be awaited first!");
22176 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
22177 // debug statements here
22179 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22181 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
22182 if(!isWasmInitialized) {
22183 throw new Error("initializeWasm() must be awaited first!");
22185 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
22186 return nativeResponseValue;
22188 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22190 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
22191 if(!isWasmInitialized) {
22192 throw new Error("initializeWasm() must be awaited first!");
22194 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
22195 return nativeResponseValue;
22197 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22199 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
22200 if(!isWasmInitialized) {
22201 throw new Error("initializeWasm() must be awaited first!");
22203 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
22204 return nativeResponseValue;
22206 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22208 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
22209 if(!isWasmInitialized) {
22210 throw new Error("initializeWasm() must be awaited first!");
22212 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
22213 return nativeResponseValue;
22215 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22217 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
22218 if(!isWasmInitialized) {
22219 throw new Error("initializeWasm() must be awaited first!");
22221 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
22222 return nativeResponseValue;
22224 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22226 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
22227 if(!isWasmInitialized) {
22228 throw new Error("initializeWasm() must be awaited first!");
22230 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
22231 return nativeResponseValue;
22233 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
22235 export function HolderCommitmentTransaction_free(this_obj: number): void {
22236 if(!isWasmInitialized) {
22237 throw new Error("initializeWasm() must be awaited first!");
22239 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
22240 // debug statements here
22242 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
22244 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
22245 if(!isWasmInitialized) {
22246 throw new Error("initializeWasm() must be awaited first!");
22248 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
22249 return nativeResponseValue;
22251 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
22253 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
22254 if(!isWasmInitialized) {
22255 throw new Error("initializeWasm() must be awaited first!");
22257 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
22258 // debug statements here
22260 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22262 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
22263 if(!isWasmInitialized) {
22264 throw new Error("initializeWasm() must be awaited first!");
22266 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
22267 // debug statements here
22269 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
22271 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
22272 if(!isWasmInitialized) {
22273 throw new Error("initializeWasm() must be awaited first!");
22275 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
22276 return nativeResponseValue;
22278 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
22280 export function HolderCommitmentTransaction_clone(orig: number): number {
22281 if(!isWasmInitialized) {
22282 throw new Error("initializeWasm() must be awaited first!");
22284 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
22285 return nativeResponseValue;
22287 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
22289 export function HolderCommitmentTransaction_write(obj: number): number {
22290 if(!isWasmInitialized) {
22291 throw new Error("initializeWasm() must be awaited first!");
22293 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
22294 return nativeResponseValue;
22296 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
22298 export function HolderCommitmentTransaction_read(ser: number): number {
22299 if(!isWasmInitialized) {
22300 throw new Error("initializeWasm() must be awaited first!");
22302 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
22303 return nativeResponseValue;
22305 // MUST_USE_RES struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_new(struct LDKCommitmentTransaction commitment_tx, struct LDKSignature counterparty_sig, struct LDKCVec_SignatureZ counterparty_htlc_sigs, struct LDKPublicKey holder_funding_key, struct LDKPublicKey counterparty_funding_key);
22307 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
22308 if(!isWasmInitialized) {
22309 throw new Error("initializeWasm() must be awaited first!");
22311 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
22312 return nativeResponseValue;
22314 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
22316 export function BuiltCommitmentTransaction_free(this_obj: number): void {
22317 if(!isWasmInitialized) {
22318 throw new Error("initializeWasm() must be awaited first!");
22320 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
22321 // debug statements here
22323 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
22325 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
22326 if(!isWasmInitialized) {
22327 throw new Error("initializeWasm() must be awaited first!");
22329 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
22330 return nativeResponseValue;
22332 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
22334 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
22335 if(!isWasmInitialized) {
22336 throw new Error("initializeWasm() must be awaited first!");
22338 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
22339 // debug statements here
22341 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
22343 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
22344 if(!isWasmInitialized) {
22345 throw new Error("initializeWasm() must be awaited first!");
22347 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
22348 return nativeResponseValue;
22350 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22352 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
22353 if(!isWasmInitialized) {
22354 throw new Error("initializeWasm() must be awaited first!");
22356 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
22357 // debug statements here
22359 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
22361 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
22362 if(!isWasmInitialized) {
22363 throw new Error("initializeWasm() must be awaited first!");
22365 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
22366 return nativeResponseValue;
22368 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
22370 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
22371 if(!isWasmInitialized) {
22372 throw new Error("initializeWasm() must be awaited first!");
22374 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
22375 return nativeResponseValue;
22377 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
22379 export function BuiltCommitmentTransaction_clone(orig: number): number {
22380 if(!isWasmInitialized) {
22381 throw new Error("initializeWasm() must be awaited first!");
22383 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
22384 return nativeResponseValue;
22386 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
22388 export function BuiltCommitmentTransaction_write(obj: number): number {
22389 if(!isWasmInitialized) {
22390 throw new Error("initializeWasm() must be awaited first!");
22392 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
22393 return nativeResponseValue;
22395 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
22397 export function BuiltCommitmentTransaction_read(ser: number): number {
22398 if(!isWasmInitialized) {
22399 throw new Error("initializeWasm() must be awaited first!");
22401 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
22402 return nativeResponseValue;
22404 // MUST_USE_RES struct LDKThirtyTwoBytes BuiltCommitmentTransaction_get_sighash_all(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
22406 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22407 if(!isWasmInitialized) {
22408 throw new Error("initializeWasm() must be awaited first!");
22410 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
22411 return nativeResponseValue;
22413 // MUST_USE_RES struct LDKSignature BuiltCommitmentTransaction_sign(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
22415 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22416 if(!isWasmInitialized) {
22417 throw new Error("initializeWasm() must be awaited first!");
22419 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
22420 return nativeResponseValue;
22422 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
22424 export function ClosingTransaction_free(this_obj: number): void {
22425 if(!isWasmInitialized) {
22426 throw new Error("initializeWasm() must be awaited first!");
22428 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
22429 // debug statements here
22431 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
22433 export function ClosingTransaction_clone_ptr(arg: number): number {
22434 if(!isWasmInitialized) {
22435 throw new Error("initializeWasm() must be awaited first!");
22437 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
22438 return nativeResponseValue;
22440 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
22442 export function ClosingTransaction_clone(orig: number): number {
22443 if(!isWasmInitialized) {
22444 throw new Error("initializeWasm() must be awaited first!");
22446 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
22447 return nativeResponseValue;
22449 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
22451 export function ClosingTransaction_hash(o: number): bigint {
22452 if(!isWasmInitialized) {
22453 throw new Error("initializeWasm() must be awaited first!");
22455 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
22456 return nativeResponseValue;
22458 // MUST_USE_RES struct LDKClosingTransaction ClosingTransaction_new(uint64_t to_holder_value_sat, uint64_t to_counterparty_value_sat, struct LDKCVec_u8Z to_holder_script, struct LDKCVec_u8Z to_counterparty_script, struct LDKOutPoint funding_outpoint);
22460 export function ClosingTransaction_new(to_holder_value_sat: bigint, to_counterparty_value_sat: bigint, to_holder_script: number, to_counterparty_script: number, funding_outpoint: number): number {
22461 if(!isWasmInitialized) {
22462 throw new Error("initializeWasm() must be awaited first!");
22464 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
22465 return nativeResponseValue;
22467 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22469 export function ClosingTransaction_trust(this_arg: number): number {
22470 if(!isWasmInitialized) {
22471 throw new Error("initializeWasm() must be awaited first!");
22473 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
22474 return nativeResponseValue;
22476 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
22478 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
22479 if(!isWasmInitialized) {
22480 throw new Error("initializeWasm() must be awaited first!");
22482 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
22483 return nativeResponseValue;
22485 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22487 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
22488 if(!isWasmInitialized) {
22489 throw new Error("initializeWasm() must be awaited first!");
22491 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
22492 return nativeResponseValue;
22494 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22496 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
22497 if(!isWasmInitialized) {
22498 throw new Error("initializeWasm() must be awaited first!");
22500 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
22501 return nativeResponseValue;
22503 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22505 export function ClosingTransaction_to_holder_script(this_arg: number): number {
22506 if(!isWasmInitialized) {
22507 throw new Error("initializeWasm() must be awaited first!");
22509 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
22510 return nativeResponseValue;
22512 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22514 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
22515 if(!isWasmInitialized) {
22516 throw new Error("initializeWasm() must be awaited first!");
22518 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
22519 return nativeResponseValue;
22521 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
22523 export function TrustedClosingTransaction_free(this_obj: number): void {
22524 if(!isWasmInitialized) {
22525 throw new Error("initializeWasm() must be awaited first!");
22527 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
22528 // debug statements here
22530 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
22532 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
22533 if(!isWasmInitialized) {
22534 throw new Error("initializeWasm() must be awaited first!");
22536 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
22537 return nativeResponseValue;
22539 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedClosingTransaction_get_sighash_all(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg, struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
22541 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22542 if(!isWasmInitialized) {
22543 throw new Error("initializeWasm() must be awaited first!");
22545 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
22546 return nativeResponseValue;
22548 // MUST_USE_RES struct LDKSignature TrustedClosingTransaction_sign(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg, const uint8_t (*funding_key)[32], struct LDKu8slice funding_redeemscript, uint64_t channel_value_satoshis);
22550 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22551 if(!isWasmInitialized) {
22552 throw new Error("initializeWasm() must be awaited first!");
22554 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
22555 return nativeResponseValue;
22557 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
22559 export function CommitmentTransaction_free(this_obj: number): void {
22560 if(!isWasmInitialized) {
22561 throw new Error("initializeWasm() must be awaited first!");
22563 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
22564 // debug statements here
22566 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
22568 export function CommitmentTransaction_clone_ptr(arg: number): number {
22569 if(!isWasmInitialized) {
22570 throw new Error("initializeWasm() must be awaited first!");
22572 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
22573 return nativeResponseValue;
22575 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
22577 export function CommitmentTransaction_clone(orig: number): number {
22578 if(!isWasmInitialized) {
22579 throw new Error("initializeWasm() must be awaited first!");
22581 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
22582 return nativeResponseValue;
22584 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
22586 export function CommitmentTransaction_write(obj: number): number {
22587 if(!isWasmInitialized) {
22588 throw new Error("initializeWasm() must be awaited first!");
22590 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
22591 return nativeResponseValue;
22593 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
22595 export function CommitmentTransaction_read(ser: number): number {
22596 if(!isWasmInitialized) {
22597 throw new Error("initializeWasm() must be awaited first!");
22599 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
22600 return nativeResponseValue;
22602 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22604 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
22605 if(!isWasmInitialized) {
22606 throw new Error("initializeWasm() must be awaited first!");
22608 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
22609 return nativeResponseValue;
22611 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22613 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
22614 if(!isWasmInitialized) {
22615 throw new Error("initializeWasm() must be awaited first!");
22617 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
22618 return nativeResponseValue;
22620 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22622 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
22623 if(!isWasmInitialized) {
22624 throw new Error("initializeWasm() must be awaited first!");
22626 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
22627 return nativeResponseValue;
22629 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22631 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
22632 if(!isWasmInitialized) {
22633 throw new Error("initializeWasm() must be awaited first!");
22635 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
22636 return nativeResponseValue;
22638 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22640 export function CommitmentTransaction_trust(this_arg: number): number {
22641 if(!isWasmInitialized) {
22642 throw new Error("initializeWasm() must be awaited first!");
22644 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
22645 return nativeResponseValue;
22647 // MUST_USE_RES struct LDKCResult_TrustedCommitmentTransactionNoneZ CommitmentTransaction_verify(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg, const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters, const struct LDKChannelPublicKeys *NONNULL_PTR broadcaster_keys, const struct LDKChannelPublicKeys *NONNULL_PTR countersignatory_keys);
22649 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
22650 if(!isWasmInitialized) {
22651 throw new Error("initializeWasm() must be awaited first!");
22653 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
22654 return nativeResponseValue;
22656 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
22658 export function TrustedCommitmentTransaction_free(this_obj: number): void {
22659 if(!isWasmInitialized) {
22660 throw new Error("initializeWasm() must be awaited first!");
22662 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
22663 // debug statements here
22665 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22667 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
22668 if(!isWasmInitialized) {
22669 throw new Error("initializeWasm() must be awaited first!");
22671 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
22672 return nativeResponseValue;
22674 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22676 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
22677 if(!isWasmInitialized) {
22678 throw new Error("initializeWasm() must be awaited first!");
22680 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
22681 return nativeResponseValue;
22683 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22685 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
22686 if(!isWasmInitialized) {
22687 throw new Error("initializeWasm() must be awaited first!");
22689 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
22690 return nativeResponseValue;
22692 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22694 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
22695 if(!isWasmInitialized) {
22696 throw new Error("initializeWasm() must be awaited first!");
22698 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
22699 return nativeResponseValue;
22701 // MUST_USE_RES struct LDKCResult_CVec_SignatureZNoneZ TrustedCommitmentTransaction_get_htlc_sigs(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg, const uint8_t (*htlc_base_key)[32], const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR channel_parameters);
22703 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
22704 if(!isWasmInitialized) {
22705 throw new Error("initializeWasm() must be awaited first!");
22707 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
22708 return nativeResponseValue;
22710 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
22712 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
22713 if(!isWasmInitialized) {
22714 throw new Error("initializeWasm() must be awaited first!");
22716 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
22717 return nativeResponseValue;
22719 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
22721 export function InitFeatures_eq(a: number, b: number): boolean {
22722 if(!isWasmInitialized) {
22723 throw new Error("initializeWasm() must be awaited first!");
22725 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
22726 return nativeResponseValue;
22728 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
22730 export function NodeFeatures_eq(a: number, b: number): boolean {
22731 if(!isWasmInitialized) {
22732 throw new Error("initializeWasm() must be awaited first!");
22734 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
22735 return nativeResponseValue;
22737 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
22739 export function ChannelFeatures_eq(a: number, b: number): boolean {
22740 if(!isWasmInitialized) {
22741 throw new Error("initializeWasm() must be awaited first!");
22743 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
22744 return nativeResponseValue;
22746 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
22748 export function InvoiceFeatures_eq(a: number, b: number): boolean {
22749 if(!isWasmInitialized) {
22750 throw new Error("initializeWasm() must be awaited first!");
22752 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
22753 return nativeResponseValue;
22755 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
22757 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
22758 if(!isWasmInitialized) {
22759 throw new Error("initializeWasm() must be awaited first!");
22761 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
22762 return nativeResponseValue;
22764 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
22766 export function InitFeatures_clone_ptr(arg: number): number {
22767 if(!isWasmInitialized) {
22768 throw new Error("initializeWasm() must be awaited first!");
22770 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
22771 return nativeResponseValue;
22773 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
22775 export function InitFeatures_clone(orig: number): number {
22776 if(!isWasmInitialized) {
22777 throw new Error("initializeWasm() must be awaited first!");
22779 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
22780 return nativeResponseValue;
22782 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
22784 export function NodeFeatures_clone_ptr(arg: number): number {
22785 if(!isWasmInitialized) {
22786 throw new Error("initializeWasm() must be awaited first!");
22788 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
22789 return nativeResponseValue;
22791 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
22793 export function NodeFeatures_clone(orig: number): number {
22794 if(!isWasmInitialized) {
22795 throw new Error("initializeWasm() must be awaited first!");
22797 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
22798 return nativeResponseValue;
22800 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
22802 export function ChannelFeatures_clone_ptr(arg: number): number {
22803 if(!isWasmInitialized) {
22804 throw new Error("initializeWasm() must be awaited first!");
22806 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
22807 return nativeResponseValue;
22809 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
22811 export function ChannelFeatures_clone(orig: number): number {
22812 if(!isWasmInitialized) {
22813 throw new Error("initializeWasm() must be awaited first!");
22815 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
22816 return nativeResponseValue;
22818 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
22820 export function InvoiceFeatures_clone_ptr(arg: number): number {
22821 if(!isWasmInitialized) {
22822 throw new Error("initializeWasm() must be awaited first!");
22824 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
22825 return nativeResponseValue;
22827 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
22829 export function InvoiceFeatures_clone(orig: number): number {
22830 if(!isWasmInitialized) {
22831 throw new Error("initializeWasm() must be awaited first!");
22833 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
22834 return nativeResponseValue;
22836 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
22838 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
22839 if(!isWasmInitialized) {
22840 throw new Error("initializeWasm() must be awaited first!");
22842 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
22843 return nativeResponseValue;
22845 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
22847 export function ChannelTypeFeatures_clone(orig: number): number {
22848 if(!isWasmInitialized) {
22849 throw new Error("initializeWasm() must be awaited first!");
22851 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
22852 return nativeResponseValue;
22854 // void InitFeatures_free(struct LDKInitFeatures this_obj);
22856 export function InitFeatures_free(this_obj: number): void {
22857 if(!isWasmInitialized) {
22858 throw new Error("initializeWasm() must be awaited first!");
22860 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
22861 // debug statements here
22863 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
22865 export function NodeFeatures_free(this_obj: number): void {
22866 if(!isWasmInitialized) {
22867 throw new Error("initializeWasm() must be awaited first!");
22869 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
22870 // debug statements here
22872 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
22874 export function ChannelFeatures_free(this_obj: number): void {
22875 if(!isWasmInitialized) {
22876 throw new Error("initializeWasm() must be awaited first!");
22878 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
22879 // debug statements here
22881 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
22883 export function InvoiceFeatures_free(this_obj: number): void {
22884 if(!isWasmInitialized) {
22885 throw new Error("initializeWasm() must be awaited first!");
22887 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
22888 // debug statements here
22890 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
22892 export function ChannelTypeFeatures_free(this_obj: number): void {
22893 if(!isWasmInitialized) {
22894 throw new Error("initializeWasm() must be awaited first!");
22896 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
22897 // debug statements here
22899 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
22901 export function InitFeatures_empty(): number {
22902 if(!isWasmInitialized) {
22903 throw new Error("initializeWasm() must be awaited first!");
22905 const nativeResponseValue = wasm.TS_InitFeatures_empty();
22906 return nativeResponseValue;
22908 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
22910 export function InitFeatures_known(): number {
22911 if(!isWasmInitialized) {
22912 throw new Error("initializeWasm() must be awaited first!");
22914 const nativeResponseValue = wasm.TS_InitFeatures_known();
22915 return nativeResponseValue;
22917 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
22919 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
22920 if(!isWasmInitialized) {
22921 throw new Error("initializeWasm() must be awaited first!");
22923 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
22924 return nativeResponseValue;
22926 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
22928 export function NodeFeatures_empty(): number {
22929 if(!isWasmInitialized) {
22930 throw new Error("initializeWasm() must be awaited first!");
22932 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
22933 return nativeResponseValue;
22935 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
22937 export function NodeFeatures_known(): number {
22938 if(!isWasmInitialized) {
22939 throw new Error("initializeWasm() must be awaited first!");
22941 const nativeResponseValue = wasm.TS_NodeFeatures_known();
22942 return nativeResponseValue;
22944 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
22946 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
22947 if(!isWasmInitialized) {
22948 throw new Error("initializeWasm() must be awaited first!");
22950 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
22951 return nativeResponseValue;
22953 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
22955 export function ChannelFeatures_empty(): number {
22956 if(!isWasmInitialized) {
22957 throw new Error("initializeWasm() must be awaited first!");
22959 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
22960 return nativeResponseValue;
22962 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
22964 export function ChannelFeatures_known(): number {
22965 if(!isWasmInitialized) {
22966 throw new Error("initializeWasm() must be awaited first!");
22968 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
22969 return nativeResponseValue;
22971 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
22973 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
22974 if(!isWasmInitialized) {
22975 throw new Error("initializeWasm() must be awaited first!");
22977 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
22978 return nativeResponseValue;
22980 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
22982 export function InvoiceFeatures_empty(): number {
22983 if(!isWasmInitialized) {
22984 throw new Error("initializeWasm() must be awaited first!");
22986 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
22987 return nativeResponseValue;
22989 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
22991 export function InvoiceFeatures_known(): number {
22992 if(!isWasmInitialized) {
22993 throw new Error("initializeWasm() must be awaited first!");
22995 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
22996 return nativeResponseValue;
22998 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
23000 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
23001 if(!isWasmInitialized) {
23002 throw new Error("initializeWasm() must be awaited first!");
23004 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
23005 return nativeResponseValue;
23007 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
23009 export function ChannelTypeFeatures_empty(): number {
23010 if(!isWasmInitialized) {
23011 throw new Error("initializeWasm() must be awaited first!");
23013 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
23014 return nativeResponseValue;
23016 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
23018 export function ChannelTypeFeatures_known(): number {
23019 if(!isWasmInitialized) {
23020 throw new Error("initializeWasm() must be awaited first!");
23022 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
23023 return nativeResponseValue;
23025 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
23027 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
23028 if(!isWasmInitialized) {
23029 throw new Error("initializeWasm() must be awaited first!");
23031 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
23032 return nativeResponseValue;
23034 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
23036 export function InitFeatures_write(obj: number): number {
23037 if(!isWasmInitialized) {
23038 throw new Error("initializeWasm() must be awaited first!");
23040 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
23041 return nativeResponseValue;
23043 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
23045 export function InitFeatures_read(ser: number): number {
23046 if(!isWasmInitialized) {
23047 throw new Error("initializeWasm() must be awaited first!");
23049 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
23050 return nativeResponseValue;
23052 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
23054 export function ChannelFeatures_write(obj: number): number {
23055 if(!isWasmInitialized) {
23056 throw new Error("initializeWasm() must be awaited first!");
23058 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
23059 return nativeResponseValue;
23061 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
23063 export function ChannelFeatures_read(ser: number): number {
23064 if(!isWasmInitialized) {
23065 throw new Error("initializeWasm() must be awaited first!");
23067 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
23068 return nativeResponseValue;
23070 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
23072 export function NodeFeatures_write(obj: number): number {
23073 if(!isWasmInitialized) {
23074 throw new Error("initializeWasm() must be awaited first!");
23076 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
23077 return nativeResponseValue;
23079 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
23081 export function NodeFeatures_read(ser: number): number {
23082 if(!isWasmInitialized) {
23083 throw new Error("initializeWasm() must be awaited first!");
23085 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
23086 return nativeResponseValue;
23088 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
23090 export function InvoiceFeatures_write(obj: number): number {
23091 if(!isWasmInitialized) {
23092 throw new Error("initializeWasm() must be awaited first!");
23094 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
23095 return nativeResponseValue;
23097 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
23099 export function InvoiceFeatures_read(ser: number): number {
23100 if(!isWasmInitialized) {
23101 throw new Error("initializeWasm() must be awaited first!");
23103 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
23104 return nativeResponseValue;
23106 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
23108 export function ChannelTypeFeatures_write(obj: number): number {
23109 if(!isWasmInitialized) {
23110 throw new Error("initializeWasm() must be awaited first!");
23112 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
23113 return nativeResponseValue;
23115 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
23117 export function ChannelTypeFeatures_read(ser: number): number {
23118 if(!isWasmInitialized) {
23119 throw new Error("initializeWasm() must be awaited first!");
23121 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
23122 return nativeResponseValue;
23124 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
23126 export function ShutdownScript_free(this_obj: number): void {
23127 if(!isWasmInitialized) {
23128 throw new Error("initializeWasm() must be awaited first!");
23130 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
23131 // debug statements here
23133 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
23135 export function ShutdownScript_clone_ptr(arg: number): number {
23136 if(!isWasmInitialized) {
23137 throw new Error("initializeWasm() must be awaited first!");
23139 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
23140 return nativeResponseValue;
23142 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
23144 export function ShutdownScript_clone(orig: number): number {
23145 if(!isWasmInitialized) {
23146 throw new Error("initializeWasm() must be awaited first!");
23148 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
23149 return nativeResponseValue;
23151 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
23153 export function InvalidShutdownScript_free(this_obj: number): void {
23154 if(!isWasmInitialized) {
23155 throw new Error("initializeWasm() must be awaited first!");
23157 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
23158 // debug statements here
23160 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
23162 export function InvalidShutdownScript_get_script(this_ptr: number): number {
23163 if(!isWasmInitialized) {
23164 throw new Error("initializeWasm() must be awaited first!");
23166 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
23167 return nativeResponseValue;
23169 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23171 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
23172 if(!isWasmInitialized) {
23173 throw new Error("initializeWasm() must be awaited first!");
23175 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
23176 // debug statements here
23178 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
23180 export function InvalidShutdownScript_new(script_arg: number): number {
23181 if(!isWasmInitialized) {
23182 throw new Error("initializeWasm() must be awaited first!");
23184 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
23185 return nativeResponseValue;
23187 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
23189 export function InvalidShutdownScript_clone_ptr(arg: number): number {
23190 if(!isWasmInitialized) {
23191 throw new Error("initializeWasm() must be awaited first!");
23193 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
23194 return nativeResponseValue;
23196 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
23198 export function InvalidShutdownScript_clone(orig: number): number {
23199 if(!isWasmInitialized) {
23200 throw new Error("initializeWasm() must be awaited first!");
23202 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
23203 return nativeResponseValue;
23205 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
23207 export function ShutdownScript_write(obj: number): number {
23208 if(!isWasmInitialized) {
23209 throw new Error("initializeWasm() must be awaited first!");
23211 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
23212 return nativeResponseValue;
23214 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
23216 export function ShutdownScript_read(ser: number): number {
23217 if(!isWasmInitialized) {
23218 throw new Error("initializeWasm() must be awaited first!");
23220 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
23221 return nativeResponseValue;
23223 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
23225 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
23226 if(!isWasmInitialized) {
23227 throw new Error("initializeWasm() must be awaited first!");
23229 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
23230 return nativeResponseValue;
23232 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
23234 export function ShutdownScript_new_p2wsh(script_hash: number): number {
23235 if(!isWasmInitialized) {
23236 throw new Error("initializeWasm() must be awaited first!");
23238 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
23239 return nativeResponseValue;
23241 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(uint8_t version, struct LDKu8slice program);
23243 export function ShutdownScript_new_witness_program(version: number, program: number): number {
23244 if(!isWasmInitialized) {
23245 throw new Error("initializeWasm() must be awaited first!");
23247 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
23248 return nativeResponseValue;
23250 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
23252 export function ShutdownScript_into_inner(this_arg: number): number {
23253 if(!isWasmInitialized) {
23254 throw new Error("initializeWasm() must be awaited first!");
23256 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
23257 return nativeResponseValue;
23259 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
23261 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
23262 if(!isWasmInitialized) {
23263 throw new Error("initializeWasm() must be awaited first!");
23265 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
23266 return nativeResponseValue;
23268 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
23270 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
23271 if(!isWasmInitialized) {
23272 throw new Error("initializeWasm() must be awaited first!");
23274 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
23275 return nativeResponseValue;
23277 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
23279 export function CustomMessageReader_free(this_ptr: number): void {
23280 if(!isWasmInitialized) {
23281 throw new Error("initializeWasm() must be awaited first!");
23283 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
23284 // debug statements here
23286 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
23288 export function Type_clone_ptr(arg: number): number {
23289 if(!isWasmInitialized) {
23290 throw new Error("initializeWasm() must be awaited first!");
23292 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
23293 return nativeResponseValue;
23295 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
23297 export function Type_clone(orig: number): number {
23298 if(!isWasmInitialized) {
23299 throw new Error("initializeWasm() must be awaited first!");
23301 const nativeResponseValue = wasm.TS_Type_clone(orig);
23302 return nativeResponseValue;
23304 // void Type_free(struct LDKType this_ptr);
23306 export function Type_free(this_ptr: number): void {
23307 if(!isWasmInitialized) {
23308 throw new Error("initializeWasm() must be awaited first!");
23310 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
23311 // debug statements here
23313 // void NodeId_free(struct LDKNodeId this_obj);
23315 export function NodeId_free(this_obj: number): void {
23316 if(!isWasmInitialized) {
23317 throw new Error("initializeWasm() must be awaited first!");
23319 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
23320 // debug statements here
23322 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
23324 export function NodeId_clone_ptr(arg: number): number {
23325 if(!isWasmInitialized) {
23326 throw new Error("initializeWasm() must be awaited first!");
23328 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
23329 return nativeResponseValue;
23331 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
23333 export function NodeId_clone(orig: number): number {
23334 if(!isWasmInitialized) {
23335 throw new Error("initializeWasm() must be awaited first!");
23337 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
23338 return nativeResponseValue;
23340 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
23342 export function NodeId_from_pubkey(pubkey: number): number {
23343 if(!isWasmInitialized) {
23344 throw new Error("initializeWasm() must be awaited first!");
23346 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
23347 return nativeResponseValue;
23349 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
23351 export function NodeId_as_slice(this_arg: number): number {
23352 if(!isWasmInitialized) {
23353 throw new Error("initializeWasm() must be awaited first!");
23355 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
23356 return nativeResponseValue;
23358 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
23360 export function NodeId_hash(o: number): bigint {
23361 if(!isWasmInitialized) {
23362 throw new Error("initializeWasm() must be awaited first!");
23364 const nativeResponseValue = wasm.TS_NodeId_hash(o);
23365 return nativeResponseValue;
23367 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
23369 export function NodeId_write(obj: number): number {
23370 if(!isWasmInitialized) {
23371 throw new Error("initializeWasm() must be awaited first!");
23373 const nativeResponseValue = wasm.TS_NodeId_write(obj);
23374 return nativeResponseValue;
23376 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
23378 export function NodeId_read(ser: number): number {
23379 if(!isWasmInitialized) {
23380 throw new Error("initializeWasm() must be awaited first!");
23382 const nativeResponseValue = wasm.TS_NodeId_read(ser);
23383 return nativeResponseValue;
23385 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
23387 export function NetworkGraph_free(this_obj: number): void {
23388 if(!isWasmInitialized) {
23389 throw new Error("initializeWasm() must be awaited first!");
23391 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
23392 // debug statements here
23394 // uintptr_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
23396 export function NetworkGraph_clone_ptr(arg: number): number {
23397 if(!isWasmInitialized) {
23398 throw new Error("initializeWasm() must be awaited first!");
23400 const nativeResponseValue = wasm.TS_NetworkGraph_clone_ptr(arg);
23401 return nativeResponseValue;
23403 // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
23405 export function NetworkGraph_clone(orig: number): number {
23406 if(!isWasmInitialized) {
23407 throw new Error("initializeWasm() must be awaited first!");
23409 const nativeResponseValue = wasm.TS_NetworkGraph_clone(orig);
23410 return nativeResponseValue;
23412 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
23414 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
23415 if(!isWasmInitialized) {
23416 throw new Error("initializeWasm() must be awaited first!");
23418 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
23419 // debug statements here
23421 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
23423 export function NetworkUpdate_free(this_ptr: number): void {
23424 if(!isWasmInitialized) {
23425 throw new Error("initializeWasm() must be awaited first!");
23427 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
23428 // debug statements here
23430 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
23432 export function NetworkUpdate_clone_ptr(arg: number): number {
23433 if(!isWasmInitialized) {
23434 throw new Error("initializeWasm() must be awaited first!");
23436 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
23437 return nativeResponseValue;
23439 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
23441 export function NetworkUpdate_clone(orig: number): number {
23442 if(!isWasmInitialized) {
23443 throw new Error("initializeWasm() must be awaited first!");
23445 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
23446 return nativeResponseValue;
23448 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
23450 export function NetworkUpdate_channel_update_message(msg: number): number {
23451 if(!isWasmInitialized) {
23452 throw new Error("initializeWasm() must be awaited first!");
23454 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
23455 return nativeResponseValue;
23457 // struct LDKNetworkUpdate NetworkUpdate_channel_closed(uint64_t short_channel_id, bool is_permanent);
23459 export function NetworkUpdate_channel_closed(short_channel_id: bigint, is_permanent: boolean): number {
23460 if(!isWasmInitialized) {
23461 throw new Error("initializeWasm() must be awaited first!");
23463 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_closed(short_channel_id, is_permanent);
23464 return nativeResponseValue;
23466 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
23468 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
23469 if(!isWasmInitialized) {
23470 throw new Error("initializeWasm() must be awaited first!");
23472 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
23473 return nativeResponseValue;
23475 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
23477 export function NetworkUpdate_write(obj: number): number {
23478 if(!isWasmInitialized) {
23479 throw new Error("initializeWasm() must be awaited first!");
23481 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
23482 return nativeResponseValue;
23484 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
23486 export function NetworkUpdate_read(ser: number): number {
23487 if(!isWasmInitialized) {
23488 throw new Error("initializeWasm() must be awaited first!");
23490 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
23491 return nativeResponseValue;
23493 // struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
23495 export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
23496 if(!isWasmInitialized) {
23497 throw new Error("initializeWasm() must be awaited first!");
23499 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_EventHandler(this_arg);
23500 return nativeResponseValue;
23502 // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
23504 export function NetGraphMsgHandler_free(this_obj: number): void {
23505 if(!isWasmInitialized) {
23506 throw new Error("initializeWasm() must be awaited first!");
23508 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_free(this_obj);
23509 // debug statements here
23511 // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
23513 export function NetGraphMsgHandler_new(network_graph: number, chain_access: number, logger: number): number {
23514 if(!isWasmInitialized) {
23515 throw new Error("initializeWasm() must be awaited first!");
23517 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_new(network_graph, chain_access, logger);
23518 return nativeResponseValue;
23520 // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
23522 export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
23523 if(!isWasmInitialized) {
23524 throw new Error("initializeWasm() must be awaited first!");
23526 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
23527 // debug statements here
23529 // struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
23531 export function NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: number): number {
23532 if(!isWasmInitialized) {
23533 throw new Error("initializeWasm() must be awaited first!");
23535 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_RoutingMessageHandler(this_arg);
23536 return nativeResponseValue;
23538 // struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
23540 export function NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg: number): number {
23541 if(!isWasmInitialized) {
23542 throw new Error("initializeWasm() must be awaited first!");
23544 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg);
23545 return nativeResponseValue;
23547 // void DirectionalChannelInfo_free(struct LDKDirectionalChannelInfo this_obj);
23549 export function DirectionalChannelInfo_free(this_obj: number): void {
23550 if(!isWasmInitialized) {
23551 throw new Error("initializeWasm() must be awaited first!");
23553 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_free(this_obj);
23554 // debug statements here
23556 // uint32_t DirectionalChannelInfo_get_last_update(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23558 export function DirectionalChannelInfo_get_last_update(this_ptr: number): number {
23559 if(!isWasmInitialized) {
23560 throw new Error("initializeWasm() must be awaited first!");
23562 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_last_update(this_ptr);
23563 return nativeResponseValue;
23565 // void DirectionalChannelInfo_set_last_update(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint32_t val);
23567 export function DirectionalChannelInfo_set_last_update(this_ptr: number, val: number): void {
23568 if(!isWasmInitialized) {
23569 throw new Error("initializeWasm() must be awaited first!");
23571 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_last_update(this_ptr, val);
23572 // debug statements here
23574 // bool DirectionalChannelInfo_get_enabled(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23576 export function DirectionalChannelInfo_get_enabled(this_ptr: number): boolean {
23577 if(!isWasmInitialized) {
23578 throw new Error("initializeWasm() must be awaited first!");
23580 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_enabled(this_ptr);
23581 return nativeResponseValue;
23583 // void DirectionalChannelInfo_set_enabled(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, bool val);
23585 export function DirectionalChannelInfo_set_enabled(this_ptr: number, val: boolean): void {
23586 if(!isWasmInitialized) {
23587 throw new Error("initializeWasm() must be awaited first!");
23589 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_enabled(this_ptr, val);
23590 // debug statements here
23592 // uint16_t DirectionalChannelInfo_get_cltv_expiry_delta(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23594 export function DirectionalChannelInfo_get_cltv_expiry_delta(this_ptr: number): number {
23595 if(!isWasmInitialized) {
23596 throw new Error("initializeWasm() must be awaited first!");
23598 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_cltv_expiry_delta(this_ptr);
23599 return nativeResponseValue;
23601 // void DirectionalChannelInfo_set_cltv_expiry_delta(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint16_t val);
23603 export function DirectionalChannelInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23604 if(!isWasmInitialized) {
23605 throw new Error("initializeWasm() must be awaited first!");
23607 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_cltv_expiry_delta(this_ptr, val);
23608 // debug statements here
23610 // uint64_t DirectionalChannelInfo_get_htlc_minimum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23612 export function DirectionalChannelInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
23613 if(!isWasmInitialized) {
23614 throw new Error("initializeWasm() must be awaited first!");
23616 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_htlc_minimum_msat(this_ptr);
23617 return nativeResponseValue;
23619 // void DirectionalChannelInfo_set_htlc_minimum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint64_t val);
23621 export function DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23622 if(!isWasmInitialized) {
23623 throw new Error("initializeWasm() must be awaited first!");
23625 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr, val);
23626 // debug statements here
23628 // struct LDKCOption_u64Z DirectionalChannelInfo_get_htlc_maximum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23630 export function DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr: number): number {
23631 if(!isWasmInitialized) {
23632 throw new Error("initializeWasm() must be awaited first!");
23634 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr);
23635 return nativeResponseValue;
23637 // void DirectionalChannelInfo_set_htlc_maximum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
23639 export function DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
23640 if(!isWasmInitialized) {
23641 throw new Error("initializeWasm() must be awaited first!");
23643 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr, val);
23644 // debug statements here
23646 // struct LDKRoutingFees DirectionalChannelInfo_get_fees(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23648 export function DirectionalChannelInfo_get_fees(this_ptr: number): number {
23649 if(!isWasmInitialized) {
23650 throw new Error("initializeWasm() must be awaited first!");
23652 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_fees(this_ptr);
23653 return nativeResponseValue;
23655 // void DirectionalChannelInfo_set_fees(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
23657 export function DirectionalChannelInfo_set_fees(this_ptr: number, val: number): void {
23658 if(!isWasmInitialized) {
23659 throw new Error("initializeWasm() must be awaited first!");
23661 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_fees(this_ptr, val);
23662 // debug statements here
23664 // struct LDKChannelUpdate DirectionalChannelInfo_get_last_update_message(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23666 export function DirectionalChannelInfo_get_last_update_message(this_ptr: number): number {
23667 if(!isWasmInitialized) {
23668 throw new Error("initializeWasm() must be awaited first!");
23670 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_last_update_message(this_ptr);
23671 return nativeResponseValue;
23673 // void DirectionalChannelInfo_set_last_update_message(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
23675 export function DirectionalChannelInfo_set_last_update_message(this_ptr: number, val: number): void {
23676 if(!isWasmInitialized) {
23677 throw new Error("initializeWasm() must be awaited first!");
23679 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_last_update_message(this_ptr, val);
23680 // debug statements here
23682 // 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);
23684 export function DirectionalChannelInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: number, fees_arg: number, last_update_message_arg: number): number {
23685 if(!isWasmInitialized) {
23686 throw new Error("initializeWasm() must be awaited first!");
23688 const nativeResponseValue = wasm.TS_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);
23689 return nativeResponseValue;
23691 // uintptr_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg);
23693 export function DirectionalChannelInfo_clone_ptr(arg: number): number {
23694 if(!isWasmInitialized) {
23695 throw new Error("initializeWasm() must be awaited first!");
23697 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_clone_ptr(arg);
23698 return nativeResponseValue;
23700 // struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
23702 export function DirectionalChannelInfo_clone(orig: number): number {
23703 if(!isWasmInitialized) {
23704 throw new Error("initializeWasm() must be awaited first!");
23706 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_clone(orig);
23707 return nativeResponseValue;
23709 // struct LDKCVec_u8Z DirectionalChannelInfo_write(const struct LDKDirectionalChannelInfo *NONNULL_PTR obj);
23711 export function DirectionalChannelInfo_write(obj: number): number {
23712 if(!isWasmInitialized) {
23713 throw new Error("initializeWasm() must be awaited first!");
23715 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_write(obj);
23716 return nativeResponseValue;
23718 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ DirectionalChannelInfo_read(struct LDKu8slice ser);
23720 export function DirectionalChannelInfo_read(ser: number): number {
23721 if(!isWasmInitialized) {
23722 throw new Error("initializeWasm() must be awaited first!");
23724 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_read(ser);
23725 return nativeResponseValue;
23727 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
23729 export function ChannelInfo_free(this_obj: number): void {
23730 if(!isWasmInitialized) {
23731 throw new Error("initializeWasm() must be awaited first!");
23733 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
23734 // debug statements here
23736 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23738 export function ChannelInfo_get_features(this_ptr: number): number {
23739 if(!isWasmInitialized) {
23740 throw new Error("initializeWasm() must be awaited first!");
23742 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
23743 return nativeResponseValue;
23745 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
23747 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
23748 if(!isWasmInitialized) {
23749 throw new Error("initializeWasm() must be awaited first!");
23751 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
23752 // debug statements here
23754 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23756 export function ChannelInfo_get_node_one(this_ptr: number): number {
23757 if(!isWasmInitialized) {
23758 throw new Error("initializeWasm() must be awaited first!");
23760 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
23761 return nativeResponseValue;
23763 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
23765 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
23766 if(!isWasmInitialized) {
23767 throw new Error("initializeWasm() must be awaited first!");
23769 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
23770 // debug statements here
23772 // struct LDKDirectionalChannelInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23774 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
23775 if(!isWasmInitialized) {
23776 throw new Error("initializeWasm() must be awaited first!");
23778 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
23779 return nativeResponseValue;
23781 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
23783 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
23784 if(!isWasmInitialized) {
23785 throw new Error("initializeWasm() must be awaited first!");
23787 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
23788 // debug statements here
23790 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23792 export function ChannelInfo_get_node_two(this_ptr: number): number {
23793 if(!isWasmInitialized) {
23794 throw new Error("initializeWasm() must be awaited first!");
23796 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
23797 return nativeResponseValue;
23799 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
23801 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
23802 if(!isWasmInitialized) {
23803 throw new Error("initializeWasm() must be awaited first!");
23805 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
23806 // debug statements here
23808 // struct LDKDirectionalChannelInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23810 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
23811 if(!isWasmInitialized) {
23812 throw new Error("initializeWasm() must be awaited first!");
23814 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
23815 return nativeResponseValue;
23817 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
23819 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
23820 if(!isWasmInitialized) {
23821 throw new Error("initializeWasm() must be awaited first!");
23823 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
23824 // debug statements here
23826 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23828 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
23829 if(!isWasmInitialized) {
23830 throw new Error("initializeWasm() must be awaited first!");
23832 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
23833 return nativeResponseValue;
23835 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
23837 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
23838 if(!isWasmInitialized) {
23839 throw new Error("initializeWasm() must be awaited first!");
23841 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
23842 // debug statements here
23844 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23846 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
23847 if(!isWasmInitialized) {
23848 throw new Error("initializeWasm() must be awaited first!");
23850 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
23851 return nativeResponseValue;
23853 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
23855 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
23856 if(!isWasmInitialized) {
23857 throw new Error("initializeWasm() must be awaited first!");
23859 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
23860 // debug statements here
23862 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
23864 export function ChannelInfo_clone_ptr(arg: number): number {
23865 if(!isWasmInitialized) {
23866 throw new Error("initializeWasm() must be awaited first!");
23868 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
23869 return nativeResponseValue;
23871 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
23873 export function ChannelInfo_clone(orig: number): number {
23874 if(!isWasmInitialized) {
23875 throw new Error("initializeWasm() must be awaited first!");
23877 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
23878 return nativeResponseValue;
23880 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
23882 export function ChannelInfo_write(obj: number): number {
23883 if(!isWasmInitialized) {
23884 throw new Error("initializeWasm() must be awaited first!");
23886 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
23887 return nativeResponseValue;
23889 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
23891 export function ChannelInfo_read(ser: number): number {
23892 if(!isWasmInitialized) {
23893 throw new Error("initializeWasm() must be awaited first!");
23895 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
23896 return nativeResponseValue;
23898 // void RoutingFees_free(struct LDKRoutingFees this_obj);
23900 export function RoutingFees_free(this_obj: number): void {
23901 if(!isWasmInitialized) {
23902 throw new Error("initializeWasm() must be awaited first!");
23904 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
23905 // debug statements here
23907 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
23909 export function RoutingFees_get_base_msat(this_ptr: number): number {
23910 if(!isWasmInitialized) {
23911 throw new Error("initializeWasm() must be awaited first!");
23913 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
23914 return nativeResponseValue;
23916 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
23918 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
23919 if(!isWasmInitialized) {
23920 throw new Error("initializeWasm() must be awaited first!");
23922 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
23923 // debug statements here
23925 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
23927 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
23928 if(!isWasmInitialized) {
23929 throw new Error("initializeWasm() must be awaited first!");
23931 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
23932 return nativeResponseValue;
23934 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
23936 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
23937 if(!isWasmInitialized) {
23938 throw new Error("initializeWasm() must be awaited first!");
23940 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
23941 // debug statements here
23943 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
23945 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
23946 if(!isWasmInitialized) {
23947 throw new Error("initializeWasm() must be awaited first!");
23949 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
23950 return nativeResponseValue;
23952 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
23954 export function RoutingFees_eq(a: number, b: number): boolean {
23955 if(!isWasmInitialized) {
23956 throw new Error("initializeWasm() must be awaited first!");
23958 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
23959 return nativeResponseValue;
23961 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
23963 export function RoutingFees_clone_ptr(arg: number): number {
23964 if(!isWasmInitialized) {
23965 throw new Error("initializeWasm() must be awaited first!");
23967 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
23968 return nativeResponseValue;
23970 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
23972 export function RoutingFees_clone(orig: number): number {
23973 if(!isWasmInitialized) {
23974 throw new Error("initializeWasm() must be awaited first!");
23976 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
23977 return nativeResponseValue;
23979 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
23981 export function RoutingFees_hash(o: number): bigint {
23982 if(!isWasmInitialized) {
23983 throw new Error("initializeWasm() must be awaited first!");
23985 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
23986 return nativeResponseValue;
23988 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
23990 export function RoutingFees_write(obj: number): number {
23991 if(!isWasmInitialized) {
23992 throw new Error("initializeWasm() must be awaited first!");
23994 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
23995 return nativeResponseValue;
23997 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
23999 export function RoutingFees_read(ser: number): number {
24000 if(!isWasmInitialized) {
24001 throw new Error("initializeWasm() must be awaited first!");
24003 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
24004 return nativeResponseValue;
24006 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
24008 export function NodeAnnouncementInfo_free(this_obj: number): void {
24009 if(!isWasmInitialized) {
24010 throw new Error("initializeWasm() must be awaited first!");
24012 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
24013 // debug statements here
24015 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
24017 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
24018 if(!isWasmInitialized) {
24019 throw new Error("initializeWasm() must be awaited first!");
24021 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
24022 return nativeResponseValue;
24024 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
24026 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
24027 if(!isWasmInitialized) {
24028 throw new Error("initializeWasm() must be awaited first!");
24030 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
24031 // debug statements here
24033 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
24035 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
24036 if(!isWasmInitialized) {
24037 throw new Error("initializeWasm() must be awaited first!");
24039 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
24040 return nativeResponseValue;
24042 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
24044 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
24045 if(!isWasmInitialized) {
24046 throw new Error("initializeWasm() must be awaited first!");
24048 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
24049 // debug statements here
24051 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
24053 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
24054 if(!isWasmInitialized) {
24055 throw new Error("initializeWasm() must be awaited first!");
24057 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
24058 return nativeResponseValue;
24060 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
24062 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
24063 if(!isWasmInitialized) {
24064 throw new Error("initializeWasm() must be awaited first!");
24066 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
24067 // debug statements here
24069 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
24071 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
24072 if(!isWasmInitialized) {
24073 throw new Error("initializeWasm() must be awaited first!");
24075 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
24076 return nativeResponseValue;
24078 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24080 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
24081 if(!isWasmInitialized) {
24082 throw new Error("initializeWasm() must be awaited first!");
24084 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
24085 // debug statements here
24087 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
24089 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
24090 if(!isWasmInitialized) {
24091 throw new Error("initializeWasm() must be awaited first!");
24093 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
24094 // debug statements here
24096 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
24098 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
24099 if(!isWasmInitialized) {
24100 throw new Error("initializeWasm() must be awaited first!");
24102 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
24103 return nativeResponseValue;
24105 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
24107 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
24108 if(!isWasmInitialized) {
24109 throw new Error("initializeWasm() must be awaited first!");
24111 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
24112 // debug statements here
24114 // 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);
24116 export function NodeAnnouncementInfo_new(features_arg: number, last_update_arg: number, rgb_arg: number, alias_arg: number, addresses_arg: number, announcement_message_arg: number): number {
24117 if(!isWasmInitialized) {
24118 throw new Error("initializeWasm() must be awaited first!");
24120 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
24121 return nativeResponseValue;
24123 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
24125 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
24126 if(!isWasmInitialized) {
24127 throw new Error("initializeWasm() must be awaited first!");
24129 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
24130 return nativeResponseValue;
24132 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
24134 export function NodeAnnouncementInfo_clone(orig: number): number {
24135 if(!isWasmInitialized) {
24136 throw new Error("initializeWasm() must be awaited first!");
24138 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
24139 return nativeResponseValue;
24141 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
24143 export function NodeAnnouncementInfo_write(obj: number): number {
24144 if(!isWasmInitialized) {
24145 throw new Error("initializeWasm() must be awaited first!");
24147 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
24148 return nativeResponseValue;
24150 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
24152 export function NodeAnnouncementInfo_read(ser: number): number {
24153 if(!isWasmInitialized) {
24154 throw new Error("initializeWasm() must be awaited first!");
24156 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
24157 return nativeResponseValue;
24159 // void NodeInfo_free(struct LDKNodeInfo this_obj);
24161 export function NodeInfo_free(this_obj: number): void {
24162 if(!isWasmInitialized) {
24163 throw new Error("initializeWasm() must be awaited first!");
24165 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
24166 // debug statements here
24168 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24170 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
24171 if(!isWasmInitialized) {
24172 throw new Error("initializeWasm() must be awaited first!");
24174 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
24175 // debug statements here
24177 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
24179 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
24180 if(!isWasmInitialized) {
24181 throw new Error("initializeWasm() must be awaited first!");
24183 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
24184 return nativeResponseValue;
24186 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
24188 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
24189 if(!isWasmInitialized) {
24190 throw new Error("initializeWasm() must be awaited first!");
24192 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
24193 // debug statements here
24195 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
24197 export function NodeInfo_get_announcement_info(this_ptr: number): number {
24198 if(!isWasmInitialized) {
24199 throw new Error("initializeWasm() must be awaited first!");
24201 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
24202 return nativeResponseValue;
24204 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
24206 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
24207 if(!isWasmInitialized) {
24208 throw new Error("initializeWasm() must be awaited first!");
24210 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
24211 // debug statements here
24213 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
24215 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
24216 if(!isWasmInitialized) {
24217 throw new Error("initializeWasm() must be awaited first!");
24219 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
24220 return nativeResponseValue;
24222 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
24224 export function NodeInfo_clone_ptr(arg: number): number {
24225 if(!isWasmInitialized) {
24226 throw new Error("initializeWasm() must be awaited first!");
24228 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
24229 return nativeResponseValue;
24231 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
24233 export function NodeInfo_clone(orig: number): number {
24234 if(!isWasmInitialized) {
24235 throw new Error("initializeWasm() must be awaited first!");
24237 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
24238 return nativeResponseValue;
24240 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
24242 export function NodeInfo_write(obj: number): number {
24243 if(!isWasmInitialized) {
24244 throw new Error("initializeWasm() must be awaited first!");
24246 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
24247 return nativeResponseValue;
24249 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
24251 export function NodeInfo_read(ser: number): number {
24252 if(!isWasmInitialized) {
24253 throw new Error("initializeWasm() must be awaited first!");
24255 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
24256 return nativeResponseValue;
24258 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
24260 export function NetworkGraph_write(obj: number): number {
24261 if(!isWasmInitialized) {
24262 throw new Error("initializeWasm() must be awaited first!");
24264 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
24265 return nativeResponseValue;
24267 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
24269 export function NetworkGraph_read(ser: number): number {
24270 if(!isWasmInitialized) {
24271 throw new Error("initializeWasm() must be awaited first!");
24273 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser);
24274 return nativeResponseValue;
24276 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
24278 export function NetworkGraph_new(genesis_hash: number): number {
24279 if(!isWasmInitialized) {
24280 throw new Error("initializeWasm() must be awaited first!");
24282 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash);
24283 return nativeResponseValue;
24285 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
24287 export function NetworkGraph_read_only(this_arg: number): number {
24288 if(!isWasmInitialized) {
24289 throw new Error("initializeWasm() must be awaited first!");
24291 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
24292 return nativeResponseValue;
24294 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
24296 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
24297 if(!isWasmInitialized) {
24298 throw new Error("initializeWasm() must be awaited first!");
24300 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
24301 return nativeResponseValue;
24303 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR msg);
24305 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
24306 if(!isWasmInitialized) {
24307 throw new Error("initializeWasm() must be awaited first!");
24309 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
24310 return nativeResponseValue;
24312 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_AccessZ chain_access);
24314 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
24315 if(!isWasmInitialized) {
24316 throw new Error("initializeWasm() must be awaited first!");
24318 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
24319 return nativeResponseValue;
24321 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_from_unsigned_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg, struct LDKCOption_AccessZ chain_access);
24323 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
24324 if(!isWasmInitialized) {
24325 throw new Error("initializeWasm() must be awaited first!");
24327 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
24328 return nativeResponseValue;
24330 // void NetworkGraph_close_channel_from_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
24332 export function NetworkGraph_close_channel_from_update(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
24333 if(!isWasmInitialized) {
24334 throw new Error("initializeWasm() must be awaited first!");
24336 const nativeResponseValue = wasm.TS_NetworkGraph_close_channel_from_update(this_arg, short_channel_id, is_permanent);
24337 // debug statements here
24339 // void NetworkGraph_fail_node(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
24341 export function NetworkGraph_fail_node(this_arg: number, _node_id: number, is_permanent: boolean): void {
24342 if(!isWasmInitialized) {
24343 throw new Error("initializeWasm() must be awaited first!");
24345 const nativeResponseValue = wasm.TS_NetworkGraph_fail_node(this_arg, _node_id, is_permanent);
24346 // debug statements here
24348 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
24350 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
24351 if(!isWasmInitialized) {
24352 throw new Error("initializeWasm() must be awaited first!");
24354 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
24355 // debug statements here
24357 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
24359 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
24360 if(!isWasmInitialized) {
24361 throw new Error("initializeWasm() must be awaited first!");
24363 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
24364 return nativeResponseValue;
24366 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
24368 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
24369 if(!isWasmInitialized) {
24370 throw new Error("initializeWasm() must be awaited first!");
24372 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
24373 return nativeResponseValue;
24375 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
24377 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
24378 if(!isWasmInitialized) {
24379 throw new Error("initializeWasm() must be awaited first!");
24381 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
24382 return nativeResponseValue;
24384 // void RouteHop_free(struct LDKRouteHop this_obj);
24386 export function RouteHop_free(this_obj: number): void {
24387 if(!isWasmInitialized) {
24388 throw new Error("initializeWasm() must be awaited first!");
24390 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
24391 // debug statements here
24393 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24395 export function RouteHop_get_pubkey(this_ptr: number): number {
24396 if(!isWasmInitialized) {
24397 throw new Error("initializeWasm() must be awaited first!");
24399 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
24400 return nativeResponseValue;
24402 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24404 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
24405 if(!isWasmInitialized) {
24406 throw new Error("initializeWasm() must be awaited first!");
24408 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
24409 // debug statements here
24411 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24413 export function RouteHop_get_node_features(this_ptr: number): number {
24414 if(!isWasmInitialized) {
24415 throw new Error("initializeWasm() must be awaited first!");
24417 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
24418 return nativeResponseValue;
24420 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
24422 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
24423 if(!isWasmInitialized) {
24424 throw new Error("initializeWasm() must be awaited first!");
24426 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
24427 // debug statements here
24429 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24431 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
24432 if(!isWasmInitialized) {
24433 throw new Error("initializeWasm() must be awaited first!");
24435 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
24436 return nativeResponseValue;
24438 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
24440 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
24441 if(!isWasmInitialized) {
24442 throw new Error("initializeWasm() must be awaited first!");
24444 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
24445 // debug statements here
24447 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24449 export function RouteHop_get_channel_features(this_ptr: number): number {
24450 if(!isWasmInitialized) {
24451 throw new Error("initializeWasm() must be awaited first!");
24453 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
24454 return nativeResponseValue;
24456 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
24458 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
24459 if(!isWasmInitialized) {
24460 throw new Error("initializeWasm() must be awaited first!");
24462 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
24463 // debug statements here
24465 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24467 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
24468 if(!isWasmInitialized) {
24469 throw new Error("initializeWasm() must be awaited first!");
24471 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
24472 return nativeResponseValue;
24474 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
24476 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
24477 if(!isWasmInitialized) {
24478 throw new Error("initializeWasm() must be awaited first!");
24480 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
24481 // debug statements here
24483 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24485 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
24486 if(!isWasmInitialized) {
24487 throw new Error("initializeWasm() must be awaited first!");
24489 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
24490 return nativeResponseValue;
24492 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
24494 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
24495 if(!isWasmInitialized) {
24496 throw new Error("initializeWasm() must be awaited first!");
24498 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
24499 // debug statements here
24501 // 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);
24503 export function RouteHop_new(pubkey_arg: number, node_features_arg: number, short_channel_id_arg: bigint, channel_features_arg: number, fee_msat_arg: bigint, cltv_expiry_delta_arg: number): number {
24504 if(!isWasmInitialized) {
24505 throw new Error("initializeWasm() must be awaited first!");
24507 const nativeResponseValue = wasm.TS_RouteHop_new(pubkey_arg, node_features_arg, short_channel_id_arg, channel_features_arg, fee_msat_arg, cltv_expiry_delta_arg);
24508 return nativeResponseValue;
24510 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
24512 export function RouteHop_clone_ptr(arg: number): number {
24513 if(!isWasmInitialized) {
24514 throw new Error("initializeWasm() must be awaited first!");
24516 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
24517 return nativeResponseValue;
24519 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
24521 export function RouteHop_clone(orig: number): number {
24522 if(!isWasmInitialized) {
24523 throw new Error("initializeWasm() must be awaited first!");
24525 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
24526 return nativeResponseValue;
24528 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
24530 export function RouteHop_hash(o: number): bigint {
24531 if(!isWasmInitialized) {
24532 throw new Error("initializeWasm() must be awaited first!");
24534 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
24535 return nativeResponseValue;
24537 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
24539 export function RouteHop_eq(a: number, b: number): boolean {
24540 if(!isWasmInitialized) {
24541 throw new Error("initializeWasm() must be awaited first!");
24543 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
24544 return nativeResponseValue;
24546 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
24548 export function RouteHop_write(obj: number): number {
24549 if(!isWasmInitialized) {
24550 throw new Error("initializeWasm() must be awaited first!");
24552 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
24553 return nativeResponseValue;
24555 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
24557 export function RouteHop_read(ser: number): number {
24558 if(!isWasmInitialized) {
24559 throw new Error("initializeWasm() must be awaited first!");
24561 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
24562 return nativeResponseValue;
24564 // void Route_free(struct LDKRoute this_obj);
24566 export function Route_free(this_obj: number): void {
24567 if(!isWasmInitialized) {
24568 throw new Error("initializeWasm() must be awaited first!");
24570 const nativeResponseValue = wasm.TS_Route_free(this_obj);
24571 // debug statements here
24573 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
24575 export function Route_get_paths(this_ptr: number): number {
24576 if(!isWasmInitialized) {
24577 throw new Error("initializeWasm() must be awaited first!");
24579 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
24580 return nativeResponseValue;
24582 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
24584 export function Route_set_paths(this_ptr: number, val: number): void {
24585 if(!isWasmInitialized) {
24586 throw new Error("initializeWasm() must be awaited first!");
24588 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
24589 // debug statements here
24591 // struct LDKPayee Route_get_payee(const struct LDKRoute *NONNULL_PTR this_ptr);
24593 export function Route_get_payee(this_ptr: number): number {
24594 if(!isWasmInitialized) {
24595 throw new Error("initializeWasm() must be awaited first!");
24597 const nativeResponseValue = wasm.TS_Route_get_payee(this_ptr);
24598 return nativeResponseValue;
24600 // void Route_set_payee(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPayee val);
24602 export function Route_set_payee(this_ptr: number, val: number): void {
24603 if(!isWasmInitialized) {
24604 throw new Error("initializeWasm() must be awaited first!");
24606 const nativeResponseValue = wasm.TS_Route_set_payee(this_ptr, val);
24607 // debug statements here
24609 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPayee payee_arg);
24611 export function Route_new(paths_arg: number, payee_arg: number): number {
24612 if(!isWasmInitialized) {
24613 throw new Error("initializeWasm() must be awaited first!");
24615 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payee_arg);
24616 return nativeResponseValue;
24618 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
24620 export function Route_clone_ptr(arg: number): number {
24621 if(!isWasmInitialized) {
24622 throw new Error("initializeWasm() must be awaited first!");
24624 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
24625 return nativeResponseValue;
24627 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
24629 export function Route_clone(orig: number): number {
24630 if(!isWasmInitialized) {
24631 throw new Error("initializeWasm() must be awaited first!");
24633 const nativeResponseValue = wasm.TS_Route_clone(orig);
24634 return nativeResponseValue;
24636 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
24638 export function Route_hash(o: number): bigint {
24639 if(!isWasmInitialized) {
24640 throw new Error("initializeWasm() must be awaited first!");
24642 const nativeResponseValue = wasm.TS_Route_hash(o);
24643 return nativeResponseValue;
24645 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
24647 export function Route_eq(a: number, b: number): boolean {
24648 if(!isWasmInitialized) {
24649 throw new Error("initializeWasm() must be awaited first!");
24651 const nativeResponseValue = wasm.TS_Route_eq(a, b);
24652 return nativeResponseValue;
24654 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
24656 export function Route_get_total_fees(this_arg: number): bigint {
24657 if(!isWasmInitialized) {
24658 throw new Error("initializeWasm() must be awaited first!");
24660 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
24661 return nativeResponseValue;
24663 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
24665 export function Route_get_total_amount(this_arg: number): bigint {
24666 if(!isWasmInitialized) {
24667 throw new Error("initializeWasm() must be awaited first!");
24669 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
24670 return nativeResponseValue;
24672 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
24674 export function Route_write(obj: number): number {
24675 if(!isWasmInitialized) {
24676 throw new Error("initializeWasm() must be awaited first!");
24678 const nativeResponseValue = wasm.TS_Route_write(obj);
24679 return nativeResponseValue;
24681 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
24683 export function Route_read(ser: number): number {
24684 if(!isWasmInitialized) {
24685 throw new Error("initializeWasm() must be awaited first!");
24687 const nativeResponseValue = wasm.TS_Route_read(ser);
24688 return nativeResponseValue;
24690 // void RouteParameters_free(struct LDKRouteParameters this_obj);
24692 export function RouteParameters_free(this_obj: number): void {
24693 if(!isWasmInitialized) {
24694 throw new Error("initializeWasm() must be awaited first!");
24696 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
24697 // debug statements here
24699 // struct LDKPayee RouteParameters_get_payee(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
24701 export function RouteParameters_get_payee(this_ptr: number): number {
24702 if(!isWasmInitialized) {
24703 throw new Error("initializeWasm() must be awaited first!");
24705 const nativeResponseValue = wasm.TS_RouteParameters_get_payee(this_ptr);
24706 return nativeResponseValue;
24708 // void RouteParameters_set_payee(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
24710 export function RouteParameters_set_payee(this_ptr: number, val: number): void {
24711 if(!isWasmInitialized) {
24712 throw new Error("initializeWasm() must be awaited first!");
24714 const nativeResponseValue = wasm.TS_RouteParameters_set_payee(this_ptr, val);
24715 // debug statements here
24717 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
24719 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
24720 if(!isWasmInitialized) {
24721 throw new Error("initializeWasm() must be awaited first!");
24723 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
24724 return nativeResponseValue;
24726 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
24728 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
24729 if(!isWasmInitialized) {
24730 throw new Error("initializeWasm() must be awaited first!");
24732 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
24733 // debug statements here
24735 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
24737 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
24738 if(!isWasmInitialized) {
24739 throw new Error("initializeWasm() must be awaited first!");
24741 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
24742 return nativeResponseValue;
24744 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
24746 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
24747 if(!isWasmInitialized) {
24748 throw new Error("initializeWasm() must be awaited first!");
24750 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
24751 // debug statements here
24753 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPayee payee_arg, uint64_t final_value_msat_arg, uint32_t final_cltv_expiry_delta_arg);
24755 export function RouteParameters_new(payee_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
24756 if(!isWasmInitialized) {
24757 throw new Error("initializeWasm() must be awaited first!");
24759 const nativeResponseValue = wasm.TS_RouteParameters_new(payee_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
24760 return nativeResponseValue;
24762 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
24764 export function RouteParameters_clone_ptr(arg: number): number {
24765 if(!isWasmInitialized) {
24766 throw new Error("initializeWasm() must be awaited first!");
24768 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
24769 return nativeResponseValue;
24771 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
24773 export function RouteParameters_clone(orig: number): number {
24774 if(!isWasmInitialized) {
24775 throw new Error("initializeWasm() must be awaited first!");
24777 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
24778 return nativeResponseValue;
24780 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
24782 export function RouteParameters_write(obj: number): number {
24783 if(!isWasmInitialized) {
24784 throw new Error("initializeWasm() must be awaited first!");
24786 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
24787 return nativeResponseValue;
24789 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
24791 export function RouteParameters_read(ser: number): number {
24792 if(!isWasmInitialized) {
24793 throw new Error("initializeWasm() must be awaited first!");
24795 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
24796 return nativeResponseValue;
24798 // void Payee_free(struct LDKPayee this_obj);
24800 export function Payee_free(this_obj: number): void {
24801 if(!isWasmInitialized) {
24802 throw new Error("initializeWasm() must be awaited first!");
24804 const nativeResponseValue = wasm.TS_Payee_free(this_obj);
24805 // debug statements here
24807 // struct LDKPublicKey Payee_get_pubkey(const struct LDKPayee *NONNULL_PTR this_ptr);
24809 export function Payee_get_pubkey(this_ptr: number): number {
24810 if(!isWasmInitialized) {
24811 throw new Error("initializeWasm() must be awaited first!");
24813 const nativeResponseValue = wasm.TS_Payee_get_pubkey(this_ptr);
24814 return nativeResponseValue;
24816 // void Payee_set_pubkey(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24818 export function Payee_set_pubkey(this_ptr: number, val: number): void {
24819 if(!isWasmInitialized) {
24820 throw new Error("initializeWasm() must be awaited first!");
24822 const nativeResponseValue = wasm.TS_Payee_set_pubkey(this_ptr, val);
24823 // debug statements here
24825 // struct LDKInvoiceFeatures Payee_get_features(const struct LDKPayee *NONNULL_PTR this_ptr);
24827 export function Payee_get_features(this_ptr: number): number {
24828 if(!isWasmInitialized) {
24829 throw new Error("initializeWasm() must be awaited first!");
24831 const nativeResponseValue = wasm.TS_Payee_get_features(this_ptr);
24832 return nativeResponseValue;
24834 // void Payee_set_features(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
24836 export function Payee_set_features(this_ptr: number, val: number): void {
24837 if(!isWasmInitialized) {
24838 throw new Error("initializeWasm() must be awaited first!");
24840 const nativeResponseValue = wasm.TS_Payee_set_features(this_ptr, val);
24841 // debug statements here
24843 // struct LDKCVec_RouteHintZ Payee_get_route_hints(const struct LDKPayee *NONNULL_PTR this_ptr);
24845 export function Payee_get_route_hints(this_ptr: number): number {
24846 if(!isWasmInitialized) {
24847 throw new Error("initializeWasm() must be awaited first!");
24849 const nativeResponseValue = wasm.TS_Payee_get_route_hints(this_ptr);
24850 return nativeResponseValue;
24852 // void Payee_set_route_hints(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
24854 export function Payee_set_route_hints(this_ptr: number, val: number): void {
24855 if(!isWasmInitialized) {
24856 throw new Error("initializeWasm() must be awaited first!");
24858 const nativeResponseValue = wasm.TS_Payee_set_route_hints(this_ptr, val);
24859 // debug statements here
24861 // struct LDKCOption_u64Z Payee_get_expiry_time(const struct LDKPayee *NONNULL_PTR this_ptr);
24863 export function Payee_get_expiry_time(this_ptr: number): number {
24864 if(!isWasmInitialized) {
24865 throw new Error("initializeWasm() must be awaited first!");
24867 const nativeResponseValue = wasm.TS_Payee_get_expiry_time(this_ptr);
24868 return nativeResponseValue;
24870 // void Payee_set_expiry_time(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
24872 export function Payee_set_expiry_time(this_ptr: number, val: number): void {
24873 if(!isWasmInitialized) {
24874 throw new Error("initializeWasm() must be awaited first!");
24876 const nativeResponseValue = wasm.TS_Payee_set_expiry_time(this_ptr, val);
24877 // debug statements here
24879 // 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);
24881 export function Payee_new(pubkey_arg: number, features_arg: number, route_hints_arg: number, expiry_time_arg: number): number {
24882 if(!isWasmInitialized) {
24883 throw new Error("initializeWasm() must be awaited first!");
24885 const nativeResponseValue = wasm.TS_Payee_new(pubkey_arg, features_arg, route_hints_arg, expiry_time_arg);
24886 return nativeResponseValue;
24888 // uintptr_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
24890 export function Payee_clone_ptr(arg: number): number {
24891 if(!isWasmInitialized) {
24892 throw new Error("initializeWasm() must be awaited first!");
24894 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
24895 return nativeResponseValue;
24897 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
24899 export function Payee_clone(orig: number): number {
24900 if(!isWasmInitialized) {
24901 throw new Error("initializeWasm() must be awaited first!");
24903 const nativeResponseValue = wasm.TS_Payee_clone(orig);
24904 return nativeResponseValue;
24906 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
24908 export function Payee_hash(o: number): bigint {
24909 if(!isWasmInitialized) {
24910 throw new Error("initializeWasm() must be awaited first!");
24912 const nativeResponseValue = wasm.TS_Payee_hash(o);
24913 return nativeResponseValue;
24915 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
24917 export function Payee_eq(a: number, b: number): boolean {
24918 if(!isWasmInitialized) {
24919 throw new Error("initializeWasm() must be awaited first!");
24921 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
24922 return nativeResponseValue;
24924 // struct LDKCVec_u8Z Payee_write(const struct LDKPayee *NONNULL_PTR obj);
24926 export function Payee_write(obj: number): number {
24927 if(!isWasmInitialized) {
24928 throw new Error("initializeWasm() must be awaited first!");
24930 const nativeResponseValue = wasm.TS_Payee_write(obj);
24931 return nativeResponseValue;
24933 // struct LDKCResult_PayeeDecodeErrorZ Payee_read(struct LDKu8slice ser);
24935 export function Payee_read(ser: number): number {
24936 if(!isWasmInitialized) {
24937 throw new Error("initializeWasm() must be awaited first!");
24939 const nativeResponseValue = wasm.TS_Payee_read(ser);
24940 return nativeResponseValue;
24942 // MUST_USE_RES struct LDKPayee Payee_from_node_id(struct LDKPublicKey pubkey);
24944 export function Payee_from_node_id(pubkey: number): number {
24945 if(!isWasmInitialized) {
24946 throw new Error("initializeWasm() must be awaited first!");
24948 const nativeResponseValue = wasm.TS_Payee_from_node_id(pubkey);
24949 return nativeResponseValue;
24951 // MUST_USE_RES struct LDKPayee Payee_for_keysend(struct LDKPublicKey pubkey);
24953 export function Payee_for_keysend(pubkey: number): number {
24954 if(!isWasmInitialized) {
24955 throw new Error("initializeWasm() must be awaited first!");
24957 const nativeResponseValue = wasm.TS_Payee_for_keysend(pubkey);
24958 return nativeResponseValue;
24960 // void RouteHint_free(struct LDKRouteHint this_obj);
24962 export function RouteHint_free(this_obj: number): void {
24963 if(!isWasmInitialized) {
24964 throw new Error("initializeWasm() must be awaited first!");
24966 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
24967 // debug statements here
24969 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
24971 export function RouteHint_get_a(this_ptr: number): number {
24972 if(!isWasmInitialized) {
24973 throw new Error("initializeWasm() must be awaited first!");
24975 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
24976 return nativeResponseValue;
24978 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
24980 export function RouteHint_set_a(this_ptr: number, val: number): void {
24981 if(!isWasmInitialized) {
24982 throw new Error("initializeWasm() must be awaited first!");
24984 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
24985 // debug statements here
24987 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
24989 export function RouteHint_new(a_arg: number): number {
24990 if(!isWasmInitialized) {
24991 throw new Error("initializeWasm() must be awaited first!");
24993 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
24994 return nativeResponseValue;
24996 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
24998 export function RouteHint_clone_ptr(arg: number): number {
24999 if(!isWasmInitialized) {
25000 throw new Error("initializeWasm() must be awaited first!");
25002 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
25003 return nativeResponseValue;
25005 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
25007 export function RouteHint_clone(orig: number): number {
25008 if(!isWasmInitialized) {
25009 throw new Error("initializeWasm() must be awaited first!");
25011 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
25012 return nativeResponseValue;
25014 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
25016 export function RouteHint_hash(o: number): bigint {
25017 if(!isWasmInitialized) {
25018 throw new Error("initializeWasm() must be awaited first!");
25020 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
25021 return nativeResponseValue;
25023 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
25025 export function RouteHint_eq(a: number, b: number): boolean {
25026 if(!isWasmInitialized) {
25027 throw new Error("initializeWasm() must be awaited first!");
25029 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
25030 return nativeResponseValue;
25032 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
25034 export function RouteHint_write(obj: number): number {
25035 if(!isWasmInitialized) {
25036 throw new Error("initializeWasm() must be awaited first!");
25038 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
25039 return nativeResponseValue;
25041 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
25043 export function RouteHint_read(ser: number): number {
25044 if(!isWasmInitialized) {
25045 throw new Error("initializeWasm() must be awaited first!");
25047 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
25048 return nativeResponseValue;
25050 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
25052 export function RouteHintHop_free(this_obj: number): void {
25053 if(!isWasmInitialized) {
25054 throw new Error("initializeWasm() must be awaited first!");
25056 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
25057 // debug statements here
25059 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25061 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
25062 if(!isWasmInitialized) {
25063 throw new Error("initializeWasm() must be awaited first!");
25065 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
25066 return nativeResponseValue;
25068 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25070 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
25071 if(!isWasmInitialized) {
25072 throw new Error("initializeWasm() must be awaited first!");
25074 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
25075 // debug statements here
25077 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25079 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
25080 if(!isWasmInitialized) {
25081 throw new Error("initializeWasm() must be awaited first!");
25083 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
25084 return nativeResponseValue;
25086 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
25088 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
25089 if(!isWasmInitialized) {
25090 throw new Error("initializeWasm() must be awaited first!");
25092 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
25093 // debug statements here
25095 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25097 export function RouteHintHop_get_fees(this_ptr: number): number {
25098 if(!isWasmInitialized) {
25099 throw new Error("initializeWasm() must be awaited first!");
25101 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
25102 return nativeResponseValue;
25104 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
25106 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
25107 if(!isWasmInitialized) {
25108 throw new Error("initializeWasm() must be awaited first!");
25110 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
25111 // debug statements here
25113 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25115 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
25116 if(!isWasmInitialized) {
25117 throw new Error("initializeWasm() must be awaited first!");
25119 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
25120 return nativeResponseValue;
25122 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
25124 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
25125 if(!isWasmInitialized) {
25126 throw new Error("initializeWasm() must be awaited first!");
25128 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
25129 // debug statements here
25131 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25133 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
25134 if(!isWasmInitialized) {
25135 throw new Error("initializeWasm() must be awaited first!");
25137 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
25138 return nativeResponseValue;
25140 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25142 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
25143 if(!isWasmInitialized) {
25144 throw new Error("initializeWasm() must be awaited first!");
25146 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
25147 // debug statements here
25149 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25151 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
25152 if(!isWasmInitialized) {
25153 throw new Error("initializeWasm() must be awaited first!");
25155 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
25156 return nativeResponseValue;
25158 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25160 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
25161 if(!isWasmInitialized) {
25162 throw new Error("initializeWasm() must be awaited first!");
25164 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
25165 // debug statements here
25167 // 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);
25169 export function RouteHintHop_new(src_node_id_arg: number, short_channel_id_arg: bigint, fees_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number, htlc_maximum_msat_arg: number): number {
25170 if(!isWasmInitialized) {
25171 throw new Error("initializeWasm() must be awaited first!");
25173 const nativeResponseValue = wasm.TS_RouteHintHop_new(src_node_id_arg, short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
25174 return nativeResponseValue;
25176 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
25178 export function RouteHintHop_clone_ptr(arg: number): number {
25179 if(!isWasmInitialized) {
25180 throw new Error("initializeWasm() must be awaited first!");
25182 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
25183 return nativeResponseValue;
25185 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
25187 export function RouteHintHop_clone(orig: number): number {
25188 if(!isWasmInitialized) {
25189 throw new Error("initializeWasm() must be awaited first!");
25191 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
25192 return nativeResponseValue;
25194 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
25196 export function RouteHintHop_hash(o: number): bigint {
25197 if(!isWasmInitialized) {
25198 throw new Error("initializeWasm() must be awaited first!");
25200 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
25201 return nativeResponseValue;
25203 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
25205 export function RouteHintHop_eq(a: number, b: number): boolean {
25206 if(!isWasmInitialized) {
25207 throw new Error("initializeWasm() must be awaited first!");
25209 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
25210 return nativeResponseValue;
25212 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
25214 export function RouteHintHop_write(obj: number): number {
25215 if(!isWasmInitialized) {
25216 throw new Error("initializeWasm() must be awaited first!");
25218 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
25219 return nativeResponseValue;
25221 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
25223 export function RouteHintHop_read(ser: number): number {
25224 if(!isWasmInitialized) {
25225 throw new Error("initializeWasm() must be awaited first!");
25227 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
25228 return nativeResponseValue;
25230 // struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR params, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer);
25232 export function find_route(our_node_pubkey: number, params: number, network: number, first_hops: number, logger: number, scorer: number): number {
25233 if(!isWasmInitialized) {
25234 throw new Error("initializeWasm() must be awaited first!");
25236 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, params, network, first_hops, logger, scorer);
25237 return nativeResponseValue;
25239 // void Score_free(struct LDKScore this_ptr);
25241 export function Score_free(this_ptr: number): void {
25242 if(!isWasmInitialized) {
25243 throw new Error("initializeWasm() must be awaited first!");
25245 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
25246 // debug statements here
25248 // void LockableScore_free(struct LDKLockableScore this_ptr);
25250 export function LockableScore_free(this_ptr: number): void {
25251 if(!isWasmInitialized) {
25252 throw new Error("initializeWasm() must be awaited first!");
25254 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
25255 // debug statements here
25257 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
25259 export function MultiThreadedLockableScore_free(this_obj: number): void {
25260 if(!isWasmInitialized) {
25261 throw new Error("initializeWasm() must be awaited first!");
25263 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
25264 // debug statements here
25266 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
25268 export function MultiThreadedLockableScore_new(score: number): number {
25269 if(!isWasmInitialized) {
25270 throw new Error("initializeWasm() must be awaited first!");
25272 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
25273 return nativeResponseValue;
25275 // void ScoringParameters_free(struct LDKScoringParameters this_obj);
25277 export function ScoringParameters_free(this_obj: number): void {
25278 if(!isWasmInitialized) {
25279 throw new Error("initializeWasm() must be awaited first!");
25281 const nativeResponseValue = wasm.TS_ScoringParameters_free(this_obj);
25282 // debug statements here
25284 // uint64_t ScoringParameters_get_base_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25286 export function ScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
25287 if(!isWasmInitialized) {
25288 throw new Error("initializeWasm() must be awaited first!");
25290 const nativeResponseValue = wasm.TS_ScoringParameters_get_base_penalty_msat(this_ptr);
25291 return nativeResponseValue;
25293 // void ScoringParameters_set_base_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25295 export function ScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
25296 if(!isWasmInitialized) {
25297 throw new Error("initializeWasm() must be awaited first!");
25299 const nativeResponseValue = wasm.TS_ScoringParameters_set_base_penalty_msat(this_ptr, val);
25300 // debug statements here
25302 // uint64_t ScoringParameters_get_failure_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25304 export function ScoringParameters_get_failure_penalty_msat(this_ptr: number): bigint {
25305 if(!isWasmInitialized) {
25306 throw new Error("initializeWasm() must be awaited first!");
25308 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_msat(this_ptr);
25309 return nativeResponseValue;
25311 // void ScoringParameters_set_failure_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25313 export function ScoringParameters_set_failure_penalty_msat(this_ptr: number, val: bigint): void {
25314 if(!isWasmInitialized) {
25315 throw new Error("initializeWasm() must be awaited first!");
25317 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_msat(this_ptr, val);
25318 // debug statements here
25320 // uint16_t ScoringParameters_get_overuse_penalty_start_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25322 export function ScoringParameters_get_overuse_penalty_start_1024th(this_ptr: number): number {
25323 if(!isWasmInitialized) {
25324 throw new Error("initializeWasm() must be awaited first!");
25326 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_start_1024th(this_ptr);
25327 return nativeResponseValue;
25329 // void ScoringParameters_set_overuse_penalty_start_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint16_t val);
25331 export function ScoringParameters_set_overuse_penalty_start_1024th(this_ptr: number, val: number): void {
25332 if(!isWasmInitialized) {
25333 throw new Error("initializeWasm() must be awaited first!");
25335 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_start_1024th(this_ptr, val);
25336 // debug statements here
25338 // uint64_t ScoringParameters_get_overuse_penalty_msat_per_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25340 export function ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr: number): bigint {
25341 if(!isWasmInitialized) {
25342 throw new Error("initializeWasm() must be awaited first!");
25344 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr);
25345 return nativeResponseValue;
25347 // void ScoringParameters_set_overuse_penalty_msat_per_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25349 export function ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr: number, val: bigint): void {
25350 if(!isWasmInitialized) {
25351 throw new Error("initializeWasm() must be awaited first!");
25353 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr, val);
25354 // debug statements here
25356 // uint64_t ScoringParameters_get_failure_penalty_half_life(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25358 export function ScoringParameters_get_failure_penalty_half_life(this_ptr: number): bigint {
25359 if(!isWasmInitialized) {
25360 throw new Error("initializeWasm() must be awaited first!");
25362 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_half_life(this_ptr);
25363 return nativeResponseValue;
25365 // void ScoringParameters_set_failure_penalty_half_life(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25367 export function ScoringParameters_set_failure_penalty_half_life(this_ptr: number, val: bigint): void {
25368 if(!isWasmInitialized) {
25369 throw new Error("initializeWasm() must be awaited first!");
25371 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_half_life(this_ptr, val);
25372 // debug statements here
25374 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_new(uint64_t base_penalty_msat_arg, uint64_t failure_penalty_msat_arg, uint16_t overuse_penalty_start_1024th_arg, uint64_t overuse_penalty_msat_per_1024th_arg, uint64_t failure_penalty_half_life_arg);
25376 export function ScoringParameters_new(base_penalty_msat_arg: bigint, failure_penalty_msat_arg: bigint, overuse_penalty_start_1024th_arg: number, overuse_penalty_msat_per_1024th_arg: bigint, failure_penalty_half_life_arg: bigint): number {
25377 if(!isWasmInitialized) {
25378 throw new Error("initializeWasm() must be awaited first!");
25380 const nativeResponseValue = wasm.TS_ScoringParameters_new(base_penalty_msat_arg, failure_penalty_msat_arg, overuse_penalty_start_1024th_arg, overuse_penalty_msat_per_1024th_arg, failure_penalty_half_life_arg);
25381 return nativeResponseValue;
25383 // struct LDKCVec_u8Z ScoringParameters_write(const struct LDKScoringParameters *NONNULL_PTR obj);
25385 export function ScoringParameters_write(obj: number): number {
25386 if(!isWasmInitialized) {
25387 throw new Error("initializeWasm() must be awaited first!");
25389 const nativeResponseValue = wasm.TS_ScoringParameters_write(obj);
25390 return nativeResponseValue;
25392 // struct LDKCResult_ScoringParametersDecodeErrorZ ScoringParameters_read(struct LDKu8slice ser);
25394 export function ScoringParameters_read(ser: number): number {
25395 if(!isWasmInitialized) {
25396 throw new Error("initializeWasm() must be awaited first!");
25398 const nativeResponseValue = wasm.TS_ScoringParameters_read(ser);
25399 return nativeResponseValue;
25401 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_default(void);
25403 export function ScoringParameters_default(): number {
25404 if(!isWasmInitialized) {
25405 throw new Error("initializeWasm() must be awaited first!");
25407 const nativeResponseValue = wasm.TS_ScoringParameters_default();
25408 return nativeResponseValue;
25412 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) {
25413 const weak: WeakRef<object> = js_objs[obj_ptr];
25414 if (weak == null || weak == undefined) {
25415 console.error("Got function call on unknown/free'd JS object!");
25416 throw new Error("Got function call on unknown/free'd JS object!");
25418 const obj: object = weak.deref();
25419 if (obj == null || obj == undefined) {
25420 console.error("Got function call on GC'd JS object!");
25421 throw new Error("Got function call on GC'd JS object!");
25425 case 0: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
25426 case 1: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
25427 case 2: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
25428 case 3: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
25429 case 4: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
25430 case 5: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
25431 case 6: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
25432 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
25433 case 8: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
25434 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
25435 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
25436 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
25437 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
25438 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
25439 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
25440 case 15: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
25441 case 16: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
25442 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
25443 case 18: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
25444 case 19: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
25445 case 20: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
25446 case 21: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
25447 case 22: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
25448 case 23: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
25449 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
25450 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
25451 case 26: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
25452 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
25453 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
25454 case 29: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
25455 case 30: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
25456 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
25457 case 32: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
25458 case 33: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
25459 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
25460 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
25461 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
25462 case 37: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
25463 case 38: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
25464 case 39: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
25465 case 40: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
25466 case 41: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
25467 case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
25468 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
25469 case 44: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
25470 case 45: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
25471 case 46: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
25472 case 47: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
25473 case 48: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
25474 case 49: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_locked"); break;
25475 case 50: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
25476 case 51: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
25477 case 52: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
25478 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
25479 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
25480 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
25481 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
25482 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
25483 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
25484 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
25485 case 60: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
25486 case 61: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
25487 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
25488 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
25489 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
25490 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
25491 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
25492 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
25493 case 68: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
25494 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
25495 case 70: fn = Object.getOwnPropertyDescriptor(obj, "sync_routing_table"); break;
25496 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
25497 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
25498 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
25499 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
25500 case 75: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
25501 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
25502 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
25503 case 78: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
25504 case 79: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
25505 case 80: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
25506 case 81: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
25507 case 82: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
25508 case 83: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
25509 case 84: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
25510 case 85: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
25511 case 86: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
25513 console.error("Got unknown function call from C!");
25514 throw new Error("Got unknown function call from C!");
25516 if (fn == null || fn == undefined) {
25517 console.error("Got function call on incorrect JS object!");
25518 throw new Error("Got function call on incorrect JS object!");
25520 return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);