2 import * as version from './version.mjs';
4 const imports: any = {};
7 var js_objs: Array<WeakRef<object>> = [];
8 var js_invoke: Function;
10 imports.wasi_snapshot_preview1 = {
11 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
12 // This should generally only be used to print panic messages
13 console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
14 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
15 for (var i = 0; i < iovec_array_len; i++) {
16 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
17 console.log(String.fromCharCode(...bytes_view));
21 "fd_close": (_fd: number) => {
22 // This is not generally called, but may be referenced in debug builds
23 console.log("wasi_snapshot_preview1:fd_close");
24 return 58; // Not Supported
26 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
27 // This is not generally called, but may be referenced in debug builds
28 console.log("wasi_snapshot_preview1:fd_seek");
29 return 58; // Not Supported
31 "random_get": (buf_ptr: number, buf_len: number) => {
32 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
33 crypto.getRandomValues(buf);
36 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
37 // This is called before fd_write to format + print panic messages
38 console.log("wasi_snapshot_preview1:environ_sizes_get");
39 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
40 out_count_view[0] = 0;
41 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
45 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
46 // This is called before fd_write to format + print panic messages
47 console.log("wasi_snapshot_preview1:environ_get");
48 return 58; // Note supported - we said there were 0 environment entries!
51 console.log("wasi_snapshot_preview1:proc_exit");
56 let isWasmInitialized: boolean = false;
59 export async function initializeWasm(uri: string) {
60 const stream = fetch(uri);
61 imports.env["js_invoke_function"] = js_invoke;
62 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
63 wasm = wasmInstance.exports;
64 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
65 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
68 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
69 throw new Error("Compiled LDK library and LDK class failes do not match");
70 // Fetching the LDK versions from C also checks that the header and binaries match
71 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
72 const ldk_ver: number = wasm.TS_get_ldk_version();
73 if (c_bindings_ver == 0)
74 throw new Error("LDK version did not match the header we built against");
76 throw new Error("LDK C bindings version did not match the header we built against");
77 const c_bindings_version: string = decodeString(c_bindings_ver)
78 const ldk_version: string = decodeString(ldk_ver);
79 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
81 isWasmInitialized = true;
86 const nextMultipleOfFour = (value: number) => {
87 return Math.ceil(value / 4) * 4;
91 export function encodeUint8Array (inputArray: Uint8Array): number {
92 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
93 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
94 arrayLengthView[0] = inputArray.length;
95 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
96 arrayMemoryView.set(inputArray);
100 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
101 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
102 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
103 arrayMemoryView.set(inputArray, 1);
104 arrayMemoryView[0] = inputArray.length;
105 return cArrayPointer;
108 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
109 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
110 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
111 arrayLengthView[0] = inputArray.length;
112 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
113 arrayMemoryView.set(inputArray);
114 return cArrayPointer;
118 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
119 if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
124 export function getArrayLength(arrayPointer: number): number {
125 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
126 return arraySizeViewer[0];
129 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
130 const arraySize = getArrayLength(arrayPointer);
131 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
132 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
133 // will free the underlying memory when it becomes unreachable instead of copying here.
134 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
135 const actualArray = actualArrayViewer.slice(0, arraySize);
137 wasm.TS_free(arrayPointer);
141 const decodeUint32Array = (arrayPointer: number, free = true) => {
142 const arraySize = getArrayLength(arrayPointer);
143 const actualArrayViewer = new Uint32Array(
144 wasm.memory.buffer, // value
145 arrayPointer + 4, // offset (ignoring length bytes)
146 arraySize // uint32 count
148 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
149 // will free the underlying memory when it becomes unreachable instead of copying here.
150 const actualArray = actualArrayViewer.slice(0, arraySize);
152 wasm.TS_free(arrayPointer);
158 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
161 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
162 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
163 return actualArrayViewer[idx];
167 export function encodeString(str: string): number {
168 const charArray = new TextEncoder().encode(str);
169 return encodeUint8Array(charArray);
173 export function decodeString(stringPointer: number, free = true): string {
174 const arraySize = getArrayLength(stringPointer);
175 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
176 const result = new TextDecoder("utf-8").decode(memoryView);
179 wasm.TS_free(stringPointer);
185 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
186 /* @internal */ export function debugPrintRemainingAllocs() { }
189 export enum AccessError {
191 * The requested chain is unknown.
193 LDKAccessError_UnknownChain,
195 * The requested transaction doesn't exist or hasn't confirmed.
197 LDKAccessError_UnknownTx,
202 export enum COption_NoneZ {
204 * When we're in this state, this COption_NoneZ contains a
206 LDKCOption_NoneZ_Some,
208 * When we're in this state, this COption_NoneZ contains nothing
210 LDKCOption_NoneZ_None,
215 export enum ChannelMonitorUpdateErr {
217 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
218 our state failed, but is expected to succeed at some point in the future).
220 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
221 submitting new commitment transactions to the counterparty. Once the update(s) that failed
222 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
223 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
226 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
227 you return a TemporaryFailure you must ensure that it is written to disk safely before
228 writing out the latest ChannelManager state.
230 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
231 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
232 to claim it on this channel) and those updates must be applied wherever they can be. At
233 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
234 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
235 the channel which would invalidate previous ChannelMonitors are not made when a channel has
238 Note that even if updates made after TemporaryFailure succeed you must still provide a
239 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
240 normal channel operation. Note that this is normally generated through a call to
241 [`ChainMonitor::channel_monitor_updated`].
243 Note that the update being processed here will not be replayed for you when you return a
244 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
245 you must store the update itself on your own local disk prior to returning a
246 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
247 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
250 For deployments where a copy of ChannelMonitors and other local state are backed up in a
251 remote location (with local copies persisted immediately), it is anticipated that all
252 updates will return TemporaryFailure until the remote copies could be updated.
254 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
256 LDKChannelMonitorUpdateErr_TemporaryFailure,
258 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
259 different watchtower and cannot update with all watchtowers that were previously informed
262 At reception of this error, ChannelManager will force-close the channel and return at
263 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
264 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
265 update must be rejected.
267 This failure may also signal a failure to update the local persisted copy of one of
268 the channel monitor instance.
270 Note that even when you fail a holder commitment transaction update, you must store the
271 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
272 broadcasts it (e.g distributed channel-monitor deployment)
274 In case of distributed watchtowers deployment, the new version must be written to disk, as
275 state may have been stored but rejected due to a block forcing a commitment broadcast. This
276 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
277 lagging behind on block processing.
279 LDKChannelMonitorUpdateErr_PermanentFailure,
284 export enum ConfirmationTarget {
286 * We are happy with this transaction confirming slowly when feerate drops some.
288 LDKConfirmationTarget_Background,
290 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
292 LDKConfirmationTarget_Normal,
294 * We'd like this transaction to confirm in the next few blocks.
296 LDKConfirmationTarget_HighPriority,
303 * Designates extremely verbose information, including gossip-induced messages
307 * Designates very low priority, often extremely verbose, information
311 * Designates lower priority information
315 * Designates useful information
319 * Designates hazardous situations
323 * Designates very serious errors
330 export enum Network {
332 * The main Bitcoin blockchain.
336 * The testnet3 blockchain.
340 * A local test blockchain.
344 * A blockchain on which blocks are signed instead of mined.
351 export enum Secp256k1Error {
353 * Signature failed verification
355 LDKSecp256k1Error_IncorrectSignature,
357 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
359 LDKSecp256k1Error_InvalidMessage,
363 LDKSecp256k1Error_InvalidPublicKey,
367 LDKSecp256k1Error_InvalidSignature,
371 LDKSecp256k1Error_InvalidSecretKey,
375 LDKSecp256k1Error_InvalidRecoveryId,
377 * Invalid tweak for add_assign or mul_assign
379 LDKSecp256k1Error_InvalidTweak,
381 * tweak_add_check failed on an xonly public key
383 LDKSecp256k1Error_TweakCheckFailed,
385 * Didn't pass enough memory to context creation with preallocated memory
387 LDKSecp256k1Error_NotEnoughMemory,
390 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
392 export function TxOut_get_script_pubkey(thing: number): number {
393 if(!isWasmInitialized) {
394 throw new Error("initializeWasm() must be awaited first!");
396 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
397 return nativeResponseValue;
399 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
401 export function TxOut_get_value(thing: number): bigint {
402 if(!isWasmInitialized) {
403 throw new Error("initializeWasm() must be awaited first!");
405 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
406 return nativeResponseValue;
408 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
410 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
411 if(!isWasmInitialized) {
412 throw new Error("initializeWasm() must be awaited first!");
414 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
415 return nativeResponseValue;
417 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
419 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
420 if(!isWasmInitialized) {
421 throw new Error("initializeWasm() must be awaited first!");
423 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
424 return nativeResponseValue;
426 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
428 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
429 if(!isWasmInitialized) {
430 throw new Error("initializeWasm() must be awaited first!");
432 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
433 return nativeResponseValue;
435 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
437 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
438 if(!isWasmInitialized) {
439 throw new Error("initializeWasm() must be awaited first!");
441 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
442 return nativeResponseValue;
444 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
446 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
447 if(!isWasmInitialized) {
448 throw new Error("initializeWasm() must be awaited first!");
450 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
451 return nativeResponseValue;
453 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
455 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
456 if(!isWasmInitialized) {
457 throw new Error("initializeWasm() must be awaited first!");
459 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
460 return nativeResponseValue;
462 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
464 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
465 if(!isWasmInitialized) {
466 throw new Error("initializeWasm() must be awaited first!");
468 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
469 return nativeResponseValue;
471 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
473 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
474 if(!isWasmInitialized) {
475 throw new Error("initializeWasm() must be awaited first!");
477 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
478 return nativeResponseValue;
480 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
482 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
483 if(!isWasmInitialized) {
484 throw new Error("initializeWasm() must be awaited first!");
486 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
487 return nativeResponseValue;
489 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
491 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
492 if(!isWasmInitialized) {
493 throw new Error("initializeWasm() must be awaited first!");
495 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
496 return nativeResponseValue;
498 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
500 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
501 if(!isWasmInitialized) {
502 throw new Error("initializeWasm() must be awaited first!");
504 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
505 return nativeResponseValue;
507 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
509 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
510 if(!isWasmInitialized) {
511 throw new Error("initializeWasm() must be awaited first!");
513 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
514 return nativeResponseValue;
516 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
518 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
519 if(!isWasmInitialized) {
520 throw new Error("initializeWasm() must be awaited first!");
522 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
523 return nativeResponseValue;
525 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
527 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
528 if(!isWasmInitialized) {
529 throw new Error("initializeWasm() must be awaited first!");
531 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
532 return nativeResponseValue;
535 export class LDKCOption_u32Z {
536 protected constructor() {}
539 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
540 if(!isWasmInitialized) {
541 throw new Error("initializeWasm() must be awaited first!");
543 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
544 return nativeResponseValue;
547 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
548 if(!isWasmInitialized) {
549 throw new Error("initializeWasm() must be awaited first!");
551 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
552 return nativeResponseValue;
554 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
556 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
557 if(!isWasmInitialized) {
558 throw new Error("initializeWasm() must be awaited first!");
560 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
561 return nativeResponseValue;
563 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
565 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
566 if(!isWasmInitialized) {
567 throw new Error("initializeWasm() must be awaited first!");
569 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
570 return nativeResponseValue;
572 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
574 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
575 if(!isWasmInitialized) {
576 throw new Error("initializeWasm() must be awaited first!");
578 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
579 return nativeResponseValue;
581 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
583 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
584 if(!isWasmInitialized) {
585 throw new Error("initializeWasm() must be awaited first!");
587 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
588 return nativeResponseValue;
590 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
592 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
593 if(!isWasmInitialized) {
594 throw new Error("initializeWasm() must be awaited first!");
596 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
597 return nativeResponseValue;
599 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
601 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
602 if(!isWasmInitialized) {
603 throw new Error("initializeWasm() must be awaited first!");
605 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
606 return nativeResponseValue;
608 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
610 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
611 if(!isWasmInitialized) {
612 throw new Error("initializeWasm() must be awaited first!");
614 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
615 return nativeResponseValue;
617 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
619 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
620 if(!isWasmInitialized) {
621 throw new Error("initializeWasm() must be awaited first!");
623 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
624 return nativeResponseValue;
626 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
628 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
629 if(!isWasmInitialized) {
630 throw new Error("initializeWasm() must be awaited first!");
632 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
633 return nativeResponseValue;
635 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
637 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
638 if(!isWasmInitialized) {
639 throw new Error("initializeWasm() must be awaited first!");
641 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
642 return nativeResponseValue;
644 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
646 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
647 if(!isWasmInitialized) {
648 throw new Error("initializeWasm() must be awaited first!");
650 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
651 return nativeResponseValue;
653 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
655 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
656 if(!isWasmInitialized) {
657 throw new Error("initializeWasm() must be awaited first!");
659 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
660 // debug statements here
662 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
664 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
665 if(!isWasmInitialized) {
666 throw new Error("initializeWasm() must be awaited first!");
668 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
669 return nativeResponseValue;
671 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
673 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
674 if(!isWasmInitialized) {
675 throw new Error("initializeWasm() must be awaited first!");
677 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
678 return nativeResponseValue;
680 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
682 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
683 if(!isWasmInitialized) {
684 throw new Error("initializeWasm() must be awaited first!");
686 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
687 return nativeResponseValue;
689 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
691 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
692 if(!isWasmInitialized) {
693 throw new Error("initializeWasm() must be awaited first!");
695 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
696 // debug statements here
698 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
700 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
701 if(!isWasmInitialized) {
702 throw new Error("initializeWasm() must be awaited first!");
704 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
705 return nativeResponseValue;
707 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
709 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
710 if(!isWasmInitialized) {
711 throw new Error("initializeWasm() must be awaited first!");
713 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
714 // debug statements here
716 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
718 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
719 if(!isWasmInitialized) {
720 throw new Error("initializeWasm() must be awaited first!");
722 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
723 return nativeResponseValue;
725 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
727 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
728 if(!isWasmInitialized) {
729 throw new Error("initializeWasm() must be awaited first!");
731 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
732 return nativeResponseValue;
734 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
736 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
737 if(!isWasmInitialized) {
738 throw new Error("initializeWasm() must be awaited first!");
740 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
741 return nativeResponseValue;
743 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
745 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
746 if(!isWasmInitialized) {
747 throw new Error("initializeWasm() must be awaited first!");
749 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
750 return nativeResponseValue;
753 export interface LDKType {
755 debug_str (): number;
760 export function LDKType_new(impl: LDKType): number {
761 if(!isWasmInitialized) {
762 throw new Error("initializeWasm() must be awaited first!");
764 var new_obj_idx = js_objs.length;
765 for (var i = 0; i < js_objs.length; i++) {
766 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
768 js_objs[i] = new WeakRef(impl);
769 return wasm.TS_LDKType_new(i);
771 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
773 export function Type_type_id(this_arg: number): number {
774 if(!isWasmInitialized) {
775 throw new Error("initializeWasm() must be awaited first!");
777 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
778 return nativeResponseValue;
780 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
782 export function Type_debug_str(this_arg: number): number {
783 if(!isWasmInitialized) {
784 throw new Error("initializeWasm() must be awaited first!");
786 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
787 return nativeResponseValue;
789 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
791 export function Type_write(this_arg: number): number {
792 if(!isWasmInitialized) {
793 throw new Error("initializeWasm() must be awaited first!");
795 const nativeResponseValue = wasm.TS_Type_write(this_arg);
796 return nativeResponseValue;
799 export class LDKCOption_TypeZ {
800 protected constructor() {}
803 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
804 if(!isWasmInitialized) {
805 throw new Error("initializeWasm() must be awaited first!");
807 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
808 return nativeResponseValue;
811 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
812 if(!isWasmInitialized) {
813 throw new Error("initializeWasm() must be awaited first!");
815 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
816 return nativeResponseValue;
818 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
820 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
821 if(!isWasmInitialized) {
822 throw new Error("initializeWasm() must be awaited first!");
824 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
825 return nativeResponseValue;
827 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
829 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
830 if(!isWasmInitialized) {
831 throw new Error("initializeWasm() must be awaited first!");
833 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
834 return nativeResponseValue;
836 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
838 export function CResult_StringErrorZ_get_ok(owner: number): number {
839 if(!isWasmInitialized) {
840 throw new Error("initializeWasm() must be awaited first!");
842 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
843 return nativeResponseValue;
845 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
847 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
848 if(!isWasmInitialized) {
849 throw new Error("initializeWasm() must be awaited first!");
851 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
852 return nativeResponseValue;
854 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
856 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
857 if(!isWasmInitialized) {
858 throw new Error("initializeWasm() must be awaited first!");
860 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
861 return nativeResponseValue;
863 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
865 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
866 if(!isWasmInitialized) {
867 throw new Error("initializeWasm() must be awaited first!");
869 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
870 return nativeResponseValue;
873 export class LDKMonitorEvent {
874 protected constructor() {}
877 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
878 if(!isWasmInitialized) {
879 throw new Error("initializeWasm() must be awaited first!");
881 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
882 return nativeResponseValue;
885 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
886 if(!isWasmInitialized) {
887 throw new Error("initializeWasm() must be awaited first!");
889 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
890 return nativeResponseValue;
893 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
894 if(!isWasmInitialized) {
895 throw new Error("initializeWasm() must be awaited first!");
897 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
898 return nativeResponseValue;
901 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
902 if(!isWasmInitialized) {
903 throw new Error("initializeWasm() must be awaited first!");
905 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
906 return nativeResponseValue;
909 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
910 if(!isWasmInitialized) {
911 throw new Error("initializeWasm() must be awaited first!");
913 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
914 return nativeResponseValue;
917 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
918 if(!isWasmInitialized) {
919 throw new Error("initializeWasm() must be awaited first!");
921 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
922 return nativeResponseValue;
925 export class LDKCOption_MonitorEventZ {
926 protected constructor() {}
929 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
930 if(!isWasmInitialized) {
931 throw new Error("initializeWasm() must be awaited first!");
933 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
934 return nativeResponseValue;
937 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
938 if(!isWasmInitialized) {
939 throw new Error("initializeWasm() must be awaited first!");
941 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
942 return nativeResponseValue;
944 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
946 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
947 if(!isWasmInitialized) {
948 throw new Error("initializeWasm() must be awaited first!");
950 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
951 return nativeResponseValue;
953 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
955 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
956 if(!isWasmInitialized) {
957 throw new Error("initializeWasm() must be awaited first!");
959 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
960 return nativeResponseValue;
962 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
964 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
965 if(!isWasmInitialized) {
966 throw new Error("initializeWasm() must be awaited first!");
968 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
969 return nativeResponseValue;
971 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
973 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
974 if(!isWasmInitialized) {
975 throw new Error("initializeWasm() must be awaited first!");
977 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
978 return nativeResponseValue;
980 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
982 export function CResult_NoneNoneZ_get_ok(owner: number): void {
983 if(!isWasmInitialized) {
984 throw new Error("initializeWasm() must be awaited first!");
986 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
987 // debug statements here
989 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
991 export function CResult_NoneNoneZ_get_err(owner: number): void {
992 if(!isWasmInitialized) {
993 throw new Error("initializeWasm() must be awaited first!");
995 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
996 // debug statements here
998 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
1000 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
1001 if(!isWasmInitialized) {
1002 throw new Error("initializeWasm() must be awaited first!");
1004 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
1005 return nativeResponseValue;
1007 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
1009 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
1010 if(!isWasmInitialized) {
1011 throw new Error("initializeWasm() must be awaited first!");
1013 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
1014 return nativeResponseValue;
1016 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
1018 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
1019 if(!isWasmInitialized) {
1020 throw new Error("initializeWasm() must be awaited first!");
1022 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
1023 return nativeResponseValue;
1025 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
1027 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
1028 if(!isWasmInitialized) {
1029 throw new Error("initializeWasm() must be awaited first!");
1031 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
1032 return nativeResponseValue;
1034 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
1036 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
1037 if(!isWasmInitialized) {
1038 throw new Error("initializeWasm() must be awaited first!");
1040 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
1041 return nativeResponseValue;
1043 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
1045 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
1046 if(!isWasmInitialized) {
1047 throw new Error("initializeWasm() must be awaited first!");
1049 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
1050 return nativeResponseValue;
1053 export class LDKPaymentPurpose {
1054 protected constructor() {}
1057 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1058 if(!isWasmInitialized) {
1059 throw new Error("initializeWasm() must be awaited first!");
1061 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1062 return nativeResponseValue;
1065 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1066 if(!isWasmInitialized) {
1067 throw new Error("initializeWasm() must be awaited first!");
1069 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1070 return nativeResponseValue;
1073 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1074 if(!isWasmInitialized) {
1075 throw new Error("initializeWasm() must be awaited first!");
1077 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1078 return nativeResponseValue;
1081 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1082 if(!isWasmInitialized) {
1083 throw new Error("initializeWasm() must be awaited first!");
1085 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1086 return nativeResponseValue;
1089 export class LDKCOption_u64Z {
1090 protected constructor() {}
1093 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1094 if(!isWasmInitialized) {
1095 throw new Error("initializeWasm() must be awaited first!");
1097 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1098 return nativeResponseValue;
1101 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1102 if(!isWasmInitialized) {
1103 throw new Error("initializeWasm() must be awaited first!");
1105 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1106 return nativeResponseValue;
1109 export class LDKNetworkUpdate {
1110 protected constructor() {}
1113 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1114 if(!isWasmInitialized) {
1115 throw new Error("initializeWasm() must be awaited first!");
1117 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1118 return nativeResponseValue;
1121 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1122 if(!isWasmInitialized) {
1123 throw new Error("initializeWasm() must be awaited first!");
1125 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1126 return nativeResponseValue;
1129 export function LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr: number): bigint {
1130 if(!isWasmInitialized) {
1131 throw new Error("initializeWasm() must be awaited first!");
1133 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr);
1134 return nativeResponseValue;
1137 export function LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr: number): boolean {
1138 if(!isWasmInitialized) {
1139 throw new Error("initializeWasm() must be awaited first!");
1141 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr);
1142 return nativeResponseValue;
1145 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1146 if(!isWasmInitialized) {
1147 throw new Error("initializeWasm() must be awaited first!");
1149 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1150 return nativeResponseValue;
1153 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1154 if(!isWasmInitialized) {
1155 throw new Error("initializeWasm() must be awaited first!");
1157 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1158 return nativeResponseValue;
1161 export class LDKCOption_NetworkUpdateZ {
1162 protected constructor() {}
1165 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1166 if(!isWasmInitialized) {
1167 throw new Error("initializeWasm() must be awaited first!");
1169 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1170 return nativeResponseValue;
1173 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1174 if(!isWasmInitialized) {
1175 throw new Error("initializeWasm() must be awaited first!");
1177 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1178 return nativeResponseValue;
1181 export class LDKSpendableOutputDescriptor {
1182 protected constructor() {}
1185 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1186 if(!isWasmInitialized) {
1187 throw new Error("initializeWasm() must be awaited first!");
1189 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1190 return nativeResponseValue;
1193 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1194 if(!isWasmInitialized) {
1195 throw new Error("initializeWasm() must be awaited first!");
1197 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1198 return nativeResponseValue;
1201 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1202 if(!isWasmInitialized) {
1203 throw new Error("initializeWasm() must be awaited first!");
1205 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1206 return nativeResponseValue;
1209 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1210 if(!isWasmInitialized) {
1211 throw new Error("initializeWasm() must be awaited first!");
1213 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1214 return nativeResponseValue;
1217 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1218 if(!isWasmInitialized) {
1219 throw new Error("initializeWasm() must be awaited first!");
1221 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1222 return nativeResponseValue;
1225 export class LDKClosureReason {
1226 protected constructor() {}
1229 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1230 if(!isWasmInitialized) {
1231 throw new Error("initializeWasm() must be awaited first!");
1233 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1234 return nativeResponseValue;
1237 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1238 if(!isWasmInitialized) {
1239 throw new Error("initializeWasm() must be awaited first!");
1241 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1242 return nativeResponseValue;
1245 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1246 if(!isWasmInitialized) {
1247 throw new Error("initializeWasm() must be awaited first!");
1249 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1250 return nativeResponseValue;
1253 export class LDKEvent {
1254 protected constructor() {}
1257 export function LDKEvent_ty_from_ptr(ptr: number): number {
1258 if(!isWasmInitialized) {
1259 throw new Error("initializeWasm() must be awaited first!");
1261 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1262 return nativeResponseValue;
1265 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1266 if(!isWasmInitialized) {
1267 throw new Error("initializeWasm() must be awaited first!");
1269 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1270 return nativeResponseValue;
1273 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1274 if(!isWasmInitialized) {
1275 throw new Error("initializeWasm() must be awaited first!");
1277 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1278 return nativeResponseValue;
1281 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1282 if(!isWasmInitialized) {
1283 throw new Error("initializeWasm() must be awaited first!");
1285 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1286 return nativeResponseValue;
1289 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1290 if(!isWasmInitialized) {
1291 throw new Error("initializeWasm() must be awaited first!");
1293 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1294 return nativeResponseValue;
1297 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1298 if(!isWasmInitialized) {
1299 throw new Error("initializeWasm() must be awaited first!");
1301 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1302 return nativeResponseValue;
1305 export function LDKEvent_PaymentReceived_get_amt(ptr: number): bigint {
1306 if(!isWasmInitialized) {
1307 throw new Error("initializeWasm() must be awaited first!");
1309 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amt(ptr);
1310 return nativeResponseValue;
1313 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1314 if(!isWasmInitialized) {
1315 throw new Error("initializeWasm() must be awaited first!");
1317 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1318 return nativeResponseValue;
1321 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1322 if(!isWasmInitialized) {
1323 throw new Error("initializeWasm() must be awaited first!");
1325 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1326 return nativeResponseValue;
1329 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1330 if(!isWasmInitialized) {
1331 throw new Error("initializeWasm() must be awaited first!");
1333 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1334 return nativeResponseValue;
1337 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1338 if(!isWasmInitialized) {
1339 throw new Error("initializeWasm() must be awaited first!");
1341 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1342 return nativeResponseValue;
1345 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1346 if(!isWasmInitialized) {
1347 throw new Error("initializeWasm() must be awaited first!");
1349 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1350 return nativeResponseValue;
1353 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1354 if(!isWasmInitialized) {
1355 throw new Error("initializeWasm() must be awaited first!");
1357 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1358 return nativeResponseValue;
1361 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1362 if(!isWasmInitialized) {
1363 throw new Error("initializeWasm() must be awaited first!");
1365 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1366 return nativeResponseValue;
1369 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1370 if(!isWasmInitialized) {
1371 throw new Error("initializeWasm() must be awaited first!");
1373 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1374 return nativeResponseValue;
1377 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1378 if(!isWasmInitialized) {
1379 throw new Error("initializeWasm() must be awaited first!");
1381 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1382 return nativeResponseValue;
1385 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1386 if(!isWasmInitialized) {
1387 throw new Error("initializeWasm() must be awaited first!");
1389 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1390 return nativeResponseValue;
1393 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1394 if(!isWasmInitialized) {
1395 throw new Error("initializeWasm() must be awaited first!");
1397 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1398 return nativeResponseValue;
1401 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1402 if(!isWasmInitialized) {
1403 throw new Error("initializeWasm() must be awaited first!");
1405 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1406 return nativeResponseValue;
1409 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1410 if(!isWasmInitialized) {
1411 throw new Error("initializeWasm() must be awaited first!");
1413 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1414 return nativeResponseValue;
1417 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1418 if(!isWasmInitialized) {
1419 throw new Error("initializeWasm() must be awaited first!");
1421 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1422 return nativeResponseValue;
1425 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1426 if(!isWasmInitialized) {
1427 throw new Error("initializeWasm() must be awaited first!");
1429 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1430 return nativeResponseValue;
1433 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1434 if(!isWasmInitialized) {
1435 throw new Error("initializeWasm() must be awaited first!");
1437 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1438 return nativeResponseValue;
1441 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1442 if(!isWasmInitialized) {
1443 throw new Error("initializeWasm() must be awaited first!");
1445 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1446 return nativeResponseValue;
1449 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1450 if(!isWasmInitialized) {
1451 throw new Error("initializeWasm() must be awaited first!");
1453 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1454 return nativeResponseValue;
1457 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1458 if(!isWasmInitialized) {
1459 throw new Error("initializeWasm() must be awaited first!");
1461 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1462 return nativeResponseValue;
1465 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1466 if(!isWasmInitialized) {
1467 throw new Error("initializeWasm() must be awaited first!");
1469 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1470 return nativeResponseValue;
1473 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1474 if(!isWasmInitialized) {
1475 throw new Error("initializeWasm() must be awaited first!");
1477 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1478 return nativeResponseValue;
1481 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1482 if(!isWasmInitialized) {
1483 throw new Error("initializeWasm() must be awaited first!");
1485 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1486 return nativeResponseValue;
1489 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1490 if(!isWasmInitialized) {
1491 throw new Error("initializeWasm() must be awaited first!");
1493 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1494 return nativeResponseValue;
1497 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1498 if(!isWasmInitialized) {
1499 throw new Error("initializeWasm() must be awaited first!");
1501 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1502 return nativeResponseValue;
1505 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1506 if(!isWasmInitialized) {
1507 throw new Error("initializeWasm() must be awaited first!");
1509 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1510 return nativeResponseValue;
1513 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1514 if(!isWasmInitialized) {
1515 throw new Error("initializeWasm() must be awaited first!");
1517 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1518 return nativeResponseValue;
1521 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1522 if(!isWasmInitialized) {
1523 throw new Error("initializeWasm() must be awaited first!");
1525 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1526 return nativeResponseValue;
1528 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1530 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
1531 if(!isWasmInitialized) {
1532 throw new Error("initializeWasm() must be awaited first!");
1534 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
1535 return nativeResponseValue;
1537 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1539 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
1540 if(!isWasmInitialized) {
1541 throw new Error("initializeWasm() must be awaited first!");
1543 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
1544 return nativeResponseValue;
1546 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
1548 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
1549 if(!isWasmInitialized) {
1550 throw new Error("initializeWasm() must be awaited first!");
1552 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
1553 return nativeResponseValue;
1555 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
1557 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
1558 if(!isWasmInitialized) {
1559 throw new Error("initializeWasm() must be awaited first!");
1561 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
1562 return nativeResponseValue;
1564 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
1566 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
1567 if(!isWasmInitialized) {
1568 throw new Error("initializeWasm() must be awaited first!");
1570 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
1571 return nativeResponseValue;
1573 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
1575 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
1576 if(!isWasmInitialized) {
1577 throw new Error("initializeWasm() must be awaited first!");
1579 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
1580 return nativeResponseValue;
1583 export class LDKBalance {
1584 protected constructor() {}
1587 export function LDKBalance_ty_from_ptr(ptr: number): number {
1588 if(!isWasmInitialized) {
1589 throw new Error("initializeWasm() must be awaited first!");
1591 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
1592 return nativeResponseValue;
1595 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
1596 if(!isWasmInitialized) {
1597 throw new Error("initializeWasm() must be awaited first!");
1599 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
1600 return nativeResponseValue;
1603 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
1604 if(!isWasmInitialized) {
1605 throw new Error("initializeWasm() must be awaited first!");
1607 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
1608 return nativeResponseValue;
1611 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
1612 if(!isWasmInitialized) {
1613 throw new Error("initializeWasm() must be awaited first!");
1615 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
1616 return nativeResponseValue;
1619 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
1620 if(!isWasmInitialized) {
1621 throw new Error("initializeWasm() must be awaited first!");
1623 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
1624 return nativeResponseValue;
1627 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
1628 if(!isWasmInitialized) {
1629 throw new Error("initializeWasm() must be awaited first!");
1631 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
1632 return nativeResponseValue;
1635 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
1636 if(!isWasmInitialized) {
1637 throw new Error("initializeWasm() must be awaited first!");
1639 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
1640 return nativeResponseValue;
1643 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
1644 if(!isWasmInitialized) {
1645 throw new Error("initializeWasm() must be awaited first!");
1647 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
1648 return nativeResponseValue;
1650 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
1652 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
1653 if(!isWasmInitialized) {
1654 throw new Error("initializeWasm() must be awaited first!");
1656 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
1657 return nativeResponseValue;
1659 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
1661 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
1662 if(!isWasmInitialized) {
1663 throw new Error("initializeWasm() must be awaited first!");
1665 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
1666 return nativeResponseValue;
1668 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
1670 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
1671 if(!isWasmInitialized) {
1672 throw new Error("initializeWasm() must be awaited first!");
1674 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
1675 return nativeResponseValue;
1677 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
1679 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
1680 if(!isWasmInitialized) {
1681 throw new Error("initializeWasm() must be awaited first!");
1683 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
1684 // debug statements here
1686 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
1688 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
1689 if(!isWasmInitialized) {
1690 throw new Error("initializeWasm() must be awaited first!");
1692 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
1693 return nativeResponseValue;
1695 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
1697 export function CResult_SignatureNoneZ_get_err(owner: number): void {
1698 if(!isWasmInitialized) {
1699 throw new Error("initializeWasm() must be awaited first!");
1701 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
1702 // debug statements here
1705 export interface LDKBaseSign {
1706 get_per_commitment_point (idx: bigint): number;
1707 release_commitment_secret (idx: bigint): number;
1708 validate_holder_commitment (holder_tx: number): number;
1709 channel_keys_id (): number;
1710 sign_counterparty_commitment (commitment_tx: number): number;
1711 validate_counterparty_revocation (idx: bigint, secret: number): number;
1712 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
1713 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
1714 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
1715 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
1716 sign_closing_transaction (closing_tx: number): number;
1717 sign_channel_announcement (msg: number): number;
1718 ready_channel (channel_parameters: number): void;
1722 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
1723 if(!isWasmInitialized) {
1724 throw new Error("initializeWasm() must be awaited first!");
1726 var new_obj_idx = js_objs.length;
1727 for (var i = 0; i < js_objs.length; i++) {
1728 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1730 js_objs[i] = new WeakRef(impl);
1731 return wasm.TS_LDKBaseSign_new(i);
1733 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
1735 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
1736 if(!isWasmInitialized) {
1737 throw new Error("initializeWasm() must be awaited first!");
1739 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
1740 return nativeResponseValue;
1742 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
1744 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
1745 if(!isWasmInitialized) {
1746 throw new Error("initializeWasm() must be awaited first!");
1748 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
1749 return nativeResponseValue;
1751 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx
1753 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number): number {
1754 if(!isWasmInitialized) {
1755 throw new Error("initializeWasm() must be awaited first!");
1757 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx);
1758 return nativeResponseValue;
1760 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
1762 export function BaseSign_channel_keys_id(this_arg: number): number {
1763 if(!isWasmInitialized) {
1764 throw new Error("initializeWasm() must be awaited first!");
1766 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
1767 return nativeResponseValue;
1769 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx
1771 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number {
1772 if(!isWasmInitialized) {
1773 throw new Error("initializeWasm() must be awaited first!");
1775 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx);
1776 return nativeResponseValue;
1778 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
1780 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
1781 if(!isWasmInitialized) {
1782 throw new Error("initializeWasm() must be awaited first!");
1784 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
1785 return nativeResponseValue;
1787 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
1789 export function BaseSign_sign_holder_commitment_and_htlcs(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_holder_commitment_and_htlcs(this_arg, commitment_tx);
1794 return nativeResponseValue;
1796 // 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]
1798 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
1799 if(!isWasmInitialized) {
1800 throw new Error("initializeWasm() must be awaited first!");
1802 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
1803 return nativeResponseValue;
1805 // 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
1807 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
1808 if(!isWasmInitialized) {
1809 throw new Error("initializeWasm() must be awaited first!");
1811 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
1812 return nativeResponseValue;
1814 // 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
1816 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
1817 if(!isWasmInitialized) {
1818 throw new Error("initializeWasm() must be awaited first!");
1820 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
1821 return nativeResponseValue;
1823 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
1825 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
1826 if(!isWasmInitialized) {
1827 throw new Error("initializeWasm() must be awaited first!");
1829 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
1830 return nativeResponseValue;
1832 // LDKCResult_SignatureNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
1834 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
1835 if(!isWasmInitialized) {
1836 throw new Error("initializeWasm() must be awaited first!");
1838 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
1839 return nativeResponseValue;
1841 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
1843 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
1844 if(!isWasmInitialized) {
1845 throw new Error("initializeWasm() must be awaited first!");
1847 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
1848 // debug statements here
1850 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
1852 export function BaseSign_get_pubkeys(this_arg: number): number {
1853 if(!isWasmInitialized) {
1854 throw new Error("initializeWasm() must be awaited first!");
1856 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
1857 return nativeResponseValue;
1860 export interface LDKSign {
1865 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
1866 if(!isWasmInitialized) {
1867 throw new Error("initializeWasm() must be awaited first!");
1869 var new_obj_idx = js_objs.length;
1870 for (var i = 0; i < js_objs.length; i++) {
1871 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
1873 js_objs[i] = new WeakRef(impl);
1874 return wasm.TS_LDKSign_new(i);
1876 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
1878 export function Sign_write(this_arg: number): number {
1879 if(!isWasmInitialized) {
1880 throw new Error("initializeWasm() must be awaited first!");
1882 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
1883 return nativeResponseValue;
1885 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
1887 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
1888 if(!isWasmInitialized) {
1889 throw new Error("initializeWasm() must be awaited first!");
1891 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
1892 return nativeResponseValue;
1894 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
1896 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
1897 if(!isWasmInitialized) {
1898 throw new Error("initializeWasm() must be awaited first!");
1900 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
1901 return nativeResponseValue;
1903 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
1905 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
1906 if(!isWasmInitialized) {
1907 throw new Error("initializeWasm() must be awaited first!");
1909 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
1910 return nativeResponseValue;
1912 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
1914 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
1915 if(!isWasmInitialized) {
1916 throw new Error("initializeWasm() must be awaited first!");
1918 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
1919 return nativeResponseValue;
1921 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1923 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
1924 if(!isWasmInitialized) {
1925 throw new Error("initializeWasm() must be awaited first!");
1927 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1928 return nativeResponseValue;
1930 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1932 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1933 if(!isWasmInitialized) {
1934 throw new Error("initializeWasm() must be awaited first!");
1936 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1937 return nativeResponseValue;
1939 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1941 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1946 return nativeResponseValue;
1948 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1950 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1951 if(!isWasmInitialized) {
1952 throw new Error("initializeWasm() must be awaited first!");
1954 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1955 return nativeResponseValue;
1957 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1959 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1960 if(!isWasmInitialized) {
1961 throw new Error("initializeWasm() must be awaited first!");
1963 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1964 return nativeResponseValue;
1966 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1968 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1973 return nativeResponseValue;
1975 // struct LDKPayee CResult_PayeeDecodeErrorZ_get_ok(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR owner);
1977 export function CResult_PayeeDecodeErrorZ_get_ok(owner: number): number {
1978 if(!isWasmInitialized) {
1979 throw new Error("initializeWasm() must be awaited first!");
1981 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_get_ok(owner);
1982 return nativeResponseValue;
1984 // struct LDKDecodeError CResult_PayeeDecodeErrorZ_get_err(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR owner);
1986 export function CResult_PayeeDecodeErrorZ_get_err(owner: number): number {
1987 if(!isWasmInitialized) {
1988 throw new Error("initializeWasm() must be awaited first!");
1990 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_get_err(owner);
1991 return nativeResponseValue;
1993 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1995 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1996 if(!isWasmInitialized) {
1997 throw new Error("initializeWasm() must be awaited first!");
1999 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
2000 return nativeResponseValue;
2002 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
2004 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
2005 if(!isWasmInitialized) {
2006 throw new Error("initializeWasm() must be awaited first!");
2008 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
2009 return nativeResponseValue;
2011 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2013 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
2014 if(!isWasmInitialized) {
2015 throw new Error("initializeWasm() must be awaited first!");
2017 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
2018 return nativeResponseValue;
2020 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
2022 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
2023 if(!isWasmInitialized) {
2024 throw new Error("initializeWasm() must be awaited first!");
2026 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
2027 return nativeResponseValue;
2029 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2031 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
2032 if(!isWasmInitialized) {
2033 throw new Error("initializeWasm() must be awaited first!");
2035 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
2036 return nativeResponseValue;
2038 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
2040 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
2041 if(!isWasmInitialized) {
2042 throw new Error("initializeWasm() must be awaited first!");
2044 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
2045 return nativeResponseValue;
2047 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2049 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2050 if(!isWasmInitialized) {
2051 throw new Error("initializeWasm() must be awaited first!");
2053 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2054 // debug statements here
2056 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2058 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2059 if(!isWasmInitialized) {
2060 throw new Error("initializeWasm() must be awaited first!");
2062 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2063 return nativeResponseValue;
2065 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
2067 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
2068 if(!isWasmInitialized) {
2069 throw new Error("initializeWasm() must be awaited first!");
2071 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
2072 return nativeResponseValue;
2074 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
2076 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
2077 if(!isWasmInitialized) {
2078 throw new Error("initializeWasm() must be awaited first!");
2080 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
2081 return nativeResponseValue;
2084 export class LDKErrorAction {
2085 protected constructor() {}
2088 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
2089 if(!isWasmInitialized) {
2090 throw new Error("initializeWasm() must be awaited first!");
2092 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
2093 return nativeResponseValue;
2096 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
2097 if(!isWasmInitialized) {
2098 throw new Error("initializeWasm() must be awaited first!");
2100 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
2101 return nativeResponseValue;
2104 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
2105 if(!isWasmInitialized) {
2106 throw new Error("initializeWasm() must be awaited first!");
2108 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
2109 return nativeResponseValue;
2112 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
2113 if(!isWasmInitialized) {
2114 throw new Error("initializeWasm() must be awaited first!");
2116 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
2117 return nativeResponseValue;
2120 export class LDKMessageSendEvent {
2121 protected constructor() {}
2124 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
2125 if(!isWasmInitialized) {
2126 throw new Error("initializeWasm() must be awaited first!");
2128 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2129 return nativeResponseValue;
2132 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
2133 if(!isWasmInitialized) {
2134 throw new Error("initializeWasm() must be awaited first!");
2136 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2137 return nativeResponseValue;
2140 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
2141 if(!isWasmInitialized) {
2142 throw new Error("initializeWasm() must be awaited first!");
2144 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2145 return nativeResponseValue;
2148 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
2149 if(!isWasmInitialized) {
2150 throw new Error("initializeWasm() must be awaited first!");
2152 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2153 return nativeResponseValue;
2156 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
2157 if(!isWasmInitialized) {
2158 throw new Error("initializeWasm() must be awaited first!");
2160 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2161 return nativeResponseValue;
2164 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
2165 if(!isWasmInitialized) {
2166 throw new Error("initializeWasm() must be awaited first!");
2168 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2169 return nativeResponseValue;
2172 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
2173 if(!isWasmInitialized) {
2174 throw new Error("initializeWasm() must be awaited first!");
2176 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2177 return nativeResponseValue;
2180 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
2181 if(!isWasmInitialized) {
2182 throw new Error("initializeWasm() must be awaited first!");
2184 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2185 return nativeResponseValue;
2188 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
2189 if(!isWasmInitialized) {
2190 throw new Error("initializeWasm() must be awaited first!");
2192 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2193 return nativeResponseValue;
2196 export function LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr: number): number {
2197 if(!isWasmInitialized) {
2198 throw new Error("initializeWasm() must be awaited first!");
2200 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr);
2201 return nativeResponseValue;
2204 export function LDKMessageSendEvent_SendFundingLocked_get_msg(ptr: number): number {
2205 if(!isWasmInitialized) {
2206 throw new Error("initializeWasm() must be awaited first!");
2208 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_msg(ptr);
2209 return nativeResponseValue;
2212 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
2213 if(!isWasmInitialized) {
2214 throw new Error("initializeWasm() must be awaited first!");
2216 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2217 return nativeResponseValue;
2220 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
2221 if(!isWasmInitialized) {
2222 throw new Error("initializeWasm() must be awaited first!");
2224 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2225 return nativeResponseValue;
2228 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
2229 if(!isWasmInitialized) {
2230 throw new Error("initializeWasm() must be awaited first!");
2232 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2233 return nativeResponseValue;
2236 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
2237 if(!isWasmInitialized) {
2238 throw new Error("initializeWasm() must be awaited first!");
2240 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2241 return nativeResponseValue;
2244 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
2245 if(!isWasmInitialized) {
2246 throw new Error("initializeWasm() must be awaited first!");
2248 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2249 return nativeResponseValue;
2252 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
2253 if(!isWasmInitialized) {
2254 throw new Error("initializeWasm() must be awaited first!");
2256 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2257 return nativeResponseValue;
2260 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
2261 if(!isWasmInitialized) {
2262 throw new Error("initializeWasm() must be awaited first!");
2264 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2265 return nativeResponseValue;
2268 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
2269 if(!isWasmInitialized) {
2270 throw new Error("initializeWasm() must be awaited first!");
2272 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2273 return nativeResponseValue;
2276 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
2277 if(!isWasmInitialized) {
2278 throw new Error("initializeWasm() must be awaited first!");
2280 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2281 return nativeResponseValue;
2284 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
2285 if(!isWasmInitialized) {
2286 throw new Error("initializeWasm() must be awaited first!");
2288 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2289 return nativeResponseValue;
2292 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2293 if(!isWasmInitialized) {
2294 throw new Error("initializeWasm() must be awaited first!");
2296 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2297 return nativeResponseValue;
2300 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2301 if(!isWasmInitialized) {
2302 throw new Error("initializeWasm() must be awaited first!");
2304 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2305 return nativeResponseValue;
2308 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2309 if(!isWasmInitialized) {
2310 throw new Error("initializeWasm() must be awaited first!");
2312 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2313 return nativeResponseValue;
2316 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2321 return nativeResponseValue;
2324 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2325 if(!isWasmInitialized) {
2326 throw new Error("initializeWasm() must be awaited first!");
2328 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2329 return nativeResponseValue;
2332 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2333 if(!isWasmInitialized) {
2334 throw new Error("initializeWasm() must be awaited first!");
2336 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2337 return nativeResponseValue;
2340 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2341 if(!isWasmInitialized) {
2342 throw new Error("initializeWasm() must be awaited first!");
2344 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2345 return nativeResponseValue;
2348 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2349 if(!isWasmInitialized) {
2350 throw new Error("initializeWasm() must be awaited first!");
2352 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2353 return nativeResponseValue;
2356 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2357 if(!isWasmInitialized) {
2358 throw new Error("initializeWasm() must be awaited first!");
2360 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2361 return nativeResponseValue;
2364 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2365 if(!isWasmInitialized) {
2366 throw new Error("initializeWasm() must be awaited first!");
2368 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2369 return nativeResponseValue;
2372 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2373 if(!isWasmInitialized) {
2374 throw new Error("initializeWasm() must be awaited first!");
2376 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2377 return nativeResponseValue;
2380 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2381 if(!isWasmInitialized) {
2382 throw new Error("initializeWasm() must be awaited first!");
2384 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2385 return nativeResponseValue;
2388 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2389 if(!isWasmInitialized) {
2390 throw new Error("initializeWasm() must be awaited first!");
2392 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2393 return nativeResponseValue;
2396 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2397 if(!isWasmInitialized) {
2398 throw new Error("initializeWasm() must be awaited first!");
2400 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2401 return nativeResponseValue;
2404 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2405 if(!isWasmInitialized) {
2406 throw new Error("initializeWasm() must be awaited first!");
2408 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2409 return nativeResponseValue;
2412 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2413 if(!isWasmInitialized) {
2414 throw new Error("initializeWasm() must be awaited first!");
2416 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2417 return nativeResponseValue;
2419 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2421 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2422 if(!isWasmInitialized) {
2423 throw new Error("initializeWasm() must be awaited first!");
2425 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2426 return nativeResponseValue;
2428 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2430 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2431 if(!isWasmInitialized) {
2432 throw new Error("initializeWasm() must be awaited first!");
2434 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2435 return nativeResponseValue;
2437 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2439 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2440 if(!isWasmInitialized) {
2441 throw new Error("initializeWasm() must be awaited first!");
2443 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2444 return nativeResponseValue;
2446 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2448 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2449 if(!isWasmInitialized) {
2450 throw new Error("initializeWasm() must be awaited first!");
2452 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2453 return nativeResponseValue;
2455 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2457 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2458 if(!isWasmInitialized) {
2459 throw new Error("initializeWasm() must be awaited first!");
2461 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2462 return nativeResponseValue;
2464 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
2466 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
2467 if(!isWasmInitialized) {
2468 throw new Error("initializeWasm() must be awaited first!");
2470 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
2471 return nativeResponseValue;
2473 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
2475 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
2476 if(!isWasmInitialized) {
2477 throw new Error("initializeWasm() must be awaited first!");
2479 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
2480 return nativeResponseValue;
2482 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
2484 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
2485 if(!isWasmInitialized) {
2486 throw new Error("initializeWasm() must be awaited first!");
2488 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
2489 // debug statements here
2491 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
2493 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
2494 if(!isWasmInitialized) {
2495 throw new Error("initializeWasm() must be awaited first!");
2497 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
2498 return nativeResponseValue;
2500 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
2502 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
2503 if(!isWasmInitialized) {
2504 throw new Error("initializeWasm() must be awaited first!");
2506 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
2507 return nativeResponseValue;
2509 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
2511 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
2512 if(!isWasmInitialized) {
2513 throw new Error("initializeWasm() must be awaited first!");
2515 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
2516 return nativeResponseValue;
2518 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2520 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2521 if(!isWasmInitialized) {
2522 throw new Error("initializeWasm() must be awaited first!");
2524 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2525 return nativeResponseValue;
2527 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2529 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2530 if(!isWasmInitialized) {
2531 throw new Error("initializeWasm() must be awaited first!");
2533 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2534 return nativeResponseValue;
2536 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2538 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2539 if(!isWasmInitialized) {
2540 throw new Error("initializeWasm() must be awaited first!");
2542 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2543 // debug statements here
2545 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2547 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2548 if(!isWasmInitialized) {
2549 throw new Error("initializeWasm() must be awaited first!");
2551 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2552 return nativeResponseValue;
2555 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2556 protected constructor() {}
2559 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2560 if(!isWasmInitialized) {
2561 throw new Error("initializeWasm() must be awaited first!");
2563 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2564 return nativeResponseValue;
2567 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2568 if(!isWasmInitialized) {
2569 throw new Error("initializeWasm() must be awaited first!");
2571 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2572 return nativeResponseValue;
2575 export class LDKCOption_ClosureReasonZ {
2576 protected constructor() {}
2579 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
2584 return nativeResponseValue;
2587 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
2588 if(!isWasmInitialized) {
2589 throw new Error("initializeWasm() must be awaited first!");
2591 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
2592 return nativeResponseValue;
2594 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
2596 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
2597 if(!isWasmInitialized) {
2598 throw new Error("initializeWasm() must be awaited first!");
2600 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
2601 return nativeResponseValue;
2603 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
2605 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
2606 if(!isWasmInitialized) {
2607 throw new Error("initializeWasm() must be awaited first!");
2609 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
2610 return nativeResponseValue;
2613 export class LDKCOption_EventZ {
2614 protected constructor() {}
2617 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
2618 if(!isWasmInitialized) {
2619 throw new Error("initializeWasm() must be awaited first!");
2621 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
2622 return nativeResponseValue;
2625 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
2626 if(!isWasmInitialized) {
2627 throw new Error("initializeWasm() must be awaited first!");
2629 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
2630 return nativeResponseValue;
2632 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2634 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
2635 if(!isWasmInitialized) {
2636 throw new Error("initializeWasm() must be awaited first!");
2638 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
2639 return nativeResponseValue;
2641 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
2643 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
2644 if(!isWasmInitialized) {
2645 throw new Error("initializeWasm() must be awaited first!");
2647 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
2648 return nativeResponseValue;
2650 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2652 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2653 if(!isWasmInitialized) {
2654 throw new Error("initializeWasm() must be awaited first!");
2656 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2657 return nativeResponseValue;
2659 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2661 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2662 if(!isWasmInitialized) {
2663 throw new Error("initializeWasm() must be awaited first!");
2665 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2666 return nativeResponseValue;
2668 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2670 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2671 if(!isWasmInitialized) {
2672 throw new Error("initializeWasm() must be awaited first!");
2674 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2675 return nativeResponseValue;
2677 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2679 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2680 if(!isWasmInitialized) {
2681 throw new Error("initializeWasm() must be awaited first!");
2683 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2684 return nativeResponseValue;
2687 export interface LDKAccess {
2688 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2692 export function LDKAccess_new(impl: LDKAccess): number {
2693 if(!isWasmInitialized) {
2694 throw new Error("initializeWasm() must be awaited first!");
2696 var new_obj_idx = js_objs.length;
2697 for (var i = 0; i < js_objs.length; i++) {
2698 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2700 js_objs[i] = new WeakRef(impl);
2701 return wasm.TS_LDKAccess_new(i);
2703 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2705 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2706 if(!isWasmInitialized) {
2707 throw new Error("initializeWasm() must be awaited first!");
2709 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2710 return nativeResponseValue;
2713 export class LDKCOption_AccessZ {
2714 protected constructor() {}
2717 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2718 if(!isWasmInitialized) {
2719 throw new Error("initializeWasm() must be awaited first!");
2721 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2722 return nativeResponseValue;
2725 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2726 if(!isWasmInitialized) {
2727 throw new Error("initializeWasm() must be awaited first!");
2729 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2730 return nativeResponseValue;
2732 // struct LDKDirectionalChannelInfo CResult_DirectionalChannelInfoDecodeErrorZ_get_ok(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2734 export function CResult_DirectionalChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2735 if(!isWasmInitialized) {
2736 throw new Error("initializeWasm() must be awaited first!");
2738 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_get_ok(owner);
2739 return nativeResponseValue;
2741 // struct LDKDecodeError CResult_DirectionalChannelInfoDecodeErrorZ_get_err(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2743 export function CResult_DirectionalChannelInfoDecodeErrorZ_get_err(owner: number): number {
2744 if(!isWasmInitialized) {
2745 throw new Error("initializeWasm() must be awaited first!");
2747 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_get_err(owner);
2748 return nativeResponseValue;
2750 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2752 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2753 if(!isWasmInitialized) {
2754 throw new Error("initializeWasm() must be awaited first!");
2756 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2757 return nativeResponseValue;
2759 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2761 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2762 if(!isWasmInitialized) {
2763 throw new Error("initializeWasm() must be awaited first!");
2765 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2766 return nativeResponseValue;
2768 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2770 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2771 if(!isWasmInitialized) {
2772 throw new Error("initializeWasm() must be awaited first!");
2774 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2775 return nativeResponseValue;
2777 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2779 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2780 if(!isWasmInitialized) {
2781 throw new Error("initializeWasm() must be awaited first!");
2783 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2784 return nativeResponseValue;
2787 export class LDKNetAddress {
2788 protected constructor() {}
2791 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2792 if(!isWasmInitialized) {
2793 throw new Error("initializeWasm() must be awaited first!");
2795 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2796 return nativeResponseValue;
2799 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2800 if(!isWasmInitialized) {
2801 throw new Error("initializeWasm() must be awaited first!");
2803 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2804 return nativeResponseValue;
2807 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2808 if(!isWasmInitialized) {
2809 throw new Error("initializeWasm() must be awaited first!");
2811 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2812 return nativeResponseValue;
2815 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2816 if(!isWasmInitialized) {
2817 throw new Error("initializeWasm() must be awaited first!");
2819 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2820 return nativeResponseValue;
2823 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2824 if(!isWasmInitialized) {
2825 throw new Error("initializeWasm() must be awaited first!");
2827 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2828 return nativeResponseValue;
2831 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2832 if(!isWasmInitialized) {
2833 throw new Error("initializeWasm() must be awaited first!");
2835 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2836 return nativeResponseValue;
2839 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2840 if(!isWasmInitialized) {
2841 throw new Error("initializeWasm() must be awaited first!");
2843 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2844 return nativeResponseValue;
2847 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2848 if(!isWasmInitialized) {
2849 throw new Error("initializeWasm() must be awaited first!");
2851 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2852 return nativeResponseValue;
2855 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2856 if(!isWasmInitialized) {
2857 throw new Error("initializeWasm() must be awaited first!");
2859 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2860 return nativeResponseValue;
2863 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2864 if(!isWasmInitialized) {
2865 throw new Error("initializeWasm() must be awaited first!");
2867 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2868 return nativeResponseValue;
2870 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2872 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2873 if(!isWasmInitialized) {
2874 throw new Error("initializeWasm() must be awaited first!");
2876 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2877 return nativeResponseValue;
2879 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2881 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2882 if(!isWasmInitialized) {
2883 throw new Error("initializeWasm() must be awaited first!");
2885 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2886 return nativeResponseValue;
2888 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2890 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2891 if(!isWasmInitialized) {
2892 throw new Error("initializeWasm() must be awaited first!");
2894 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
2895 return nativeResponseValue;
2897 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2899 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
2900 if(!isWasmInitialized) {
2901 throw new Error("initializeWasm() must be awaited first!");
2903 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
2904 return nativeResponseValue;
2906 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2908 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
2909 if(!isWasmInitialized) {
2910 throw new Error("initializeWasm() must be awaited first!");
2912 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
2913 return nativeResponseValue;
2915 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2917 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
2918 if(!isWasmInitialized) {
2919 throw new Error("initializeWasm() must be awaited first!");
2921 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
2922 return nativeResponseValue;
2925 export class LDKCOption_CVec_NetAddressZZ {
2926 protected constructor() {}
2929 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
2930 if(!isWasmInitialized) {
2931 throw new Error("initializeWasm() must be awaited first!");
2933 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
2934 return nativeResponseValue;
2937 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
2938 if(!isWasmInitialized) {
2939 throw new Error("initializeWasm() must be awaited first!");
2941 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
2942 return nativeResponseValue;
2944 // struct LDKScoringParameters *CResult_ScoringParametersDecodeErrorZ_get_ok(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2946 export function CResult_ScoringParametersDecodeErrorZ_get_ok(owner: number): number {
2947 if(!isWasmInitialized) {
2948 throw new Error("initializeWasm() must be awaited first!");
2950 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_ok(owner);
2951 return nativeResponseValue;
2953 // struct LDKDecodeError CResult_ScoringParametersDecodeErrorZ_get_err(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2955 export function CResult_ScoringParametersDecodeErrorZ_get_err(owner: number): number {
2956 if(!isWasmInitialized) {
2957 throw new Error("initializeWasm() must be awaited first!");
2959 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_err(owner);
2960 return nativeResponseValue;
2962 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2964 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2965 if(!isWasmInitialized) {
2966 throw new Error("initializeWasm() must be awaited first!");
2968 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2969 return nativeResponseValue;
2971 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2973 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2974 if(!isWasmInitialized) {
2975 throw new Error("initializeWasm() must be awaited first!");
2977 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2978 return nativeResponseValue;
2980 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2982 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2983 if(!isWasmInitialized) {
2984 throw new Error("initializeWasm() must be awaited first!");
2986 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2987 return nativeResponseValue;
2989 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2991 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2992 if(!isWasmInitialized) {
2993 throw new Error("initializeWasm() must be awaited first!");
2995 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2996 return nativeResponseValue;
2998 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3000 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
3001 if(!isWasmInitialized) {
3002 throw new Error("initializeWasm() must be awaited first!");
3004 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
3005 return nativeResponseValue;
3007 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3009 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
3010 if(!isWasmInitialized) {
3011 throw new Error("initializeWasm() must be awaited first!");
3013 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
3014 return nativeResponseValue;
3016 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3018 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
3019 if(!isWasmInitialized) {
3020 throw new Error("initializeWasm() must be awaited first!");
3022 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
3023 return nativeResponseValue;
3025 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
3027 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
3028 if(!isWasmInitialized) {
3029 throw new Error("initializeWasm() must be awaited first!");
3031 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
3032 return nativeResponseValue;
3034 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3036 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
3041 return nativeResponseValue;
3043 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
3045 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
3050 return nativeResponseValue;
3052 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
3054 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
3055 if(!isWasmInitialized) {
3056 throw new Error("initializeWasm() must be awaited first!");
3058 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
3059 return nativeResponseValue;
3061 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
3063 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
3068 return nativeResponseValue;
3070 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
3072 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
3077 return nativeResponseValue;
3079 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
3081 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
3086 return nativeResponseValue;
3088 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
3090 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
3095 return nativeResponseValue;
3097 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
3099 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
3104 return nativeResponseValue;
3106 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
3108 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
3113 return nativeResponseValue;
3115 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
3117 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
3122 return nativeResponseValue;
3124 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
3126 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
3131 return nativeResponseValue;
3133 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
3135 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
3140 return nativeResponseValue;
3142 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
3144 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
3149 return nativeResponseValue;
3151 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
3153 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
3158 return nativeResponseValue;
3160 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
3162 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
3163 if(!isWasmInitialized) {
3164 throw new Error("initializeWasm() must be awaited first!");
3166 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
3167 return nativeResponseValue;
3169 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
3171 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
3172 if(!isWasmInitialized) {
3173 throw new Error("initializeWasm() must be awaited first!");
3175 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
3176 return nativeResponseValue;
3178 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
3180 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
3181 if(!isWasmInitialized) {
3182 throw new Error("initializeWasm() must be awaited first!");
3184 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
3185 return nativeResponseValue;
3187 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
3189 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
3190 if(!isWasmInitialized) {
3191 throw new Error("initializeWasm() must be awaited first!");
3193 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
3194 return nativeResponseValue;
3196 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
3198 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
3199 if(!isWasmInitialized) {
3200 throw new Error("initializeWasm() must be awaited first!");
3202 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
3203 return nativeResponseValue;
3205 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
3207 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
3208 if(!isWasmInitialized) {
3209 throw new Error("initializeWasm() must be awaited first!");
3211 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
3212 return nativeResponseValue;
3214 // struct LDKFundingLocked CResult_FundingLockedDecodeErrorZ_get_ok(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
3216 export function CResult_FundingLockedDecodeErrorZ_get_ok(owner: number): number {
3217 if(!isWasmInitialized) {
3218 throw new Error("initializeWasm() must be awaited first!");
3220 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_ok(owner);
3221 return nativeResponseValue;
3223 // struct LDKDecodeError CResult_FundingLockedDecodeErrorZ_get_err(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
3225 export function CResult_FundingLockedDecodeErrorZ_get_err(owner: number): number {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_err(owner);
3230 return nativeResponseValue;
3232 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
3234 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
3235 if(!isWasmInitialized) {
3236 throw new Error("initializeWasm() must be awaited first!");
3238 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
3239 return nativeResponseValue;
3241 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
3243 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
3248 return nativeResponseValue;
3250 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
3252 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
3253 if(!isWasmInitialized) {
3254 throw new Error("initializeWasm() must be awaited first!");
3256 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
3257 return nativeResponseValue;
3259 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
3261 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
3262 if(!isWasmInitialized) {
3263 throw new Error("initializeWasm() must be awaited first!");
3265 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
3266 return nativeResponseValue;
3268 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
3270 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
3271 if(!isWasmInitialized) {
3272 throw new Error("initializeWasm() must be awaited first!");
3274 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
3275 return nativeResponseValue;
3277 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
3279 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
3280 if(!isWasmInitialized) {
3281 throw new Error("initializeWasm() must be awaited first!");
3283 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
3284 return nativeResponseValue;
3286 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
3288 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
3289 if(!isWasmInitialized) {
3290 throw new Error("initializeWasm() must be awaited first!");
3292 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
3293 return nativeResponseValue;
3295 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
3297 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
3298 if(!isWasmInitialized) {
3299 throw new Error("initializeWasm() must be awaited first!");
3301 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
3302 return nativeResponseValue;
3304 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
3306 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
3307 if(!isWasmInitialized) {
3308 throw new Error("initializeWasm() must be awaited first!");
3310 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
3311 return nativeResponseValue;
3313 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
3315 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
3316 if(!isWasmInitialized) {
3317 throw new Error("initializeWasm() must be awaited first!");
3319 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
3320 return nativeResponseValue;
3322 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
3324 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
3325 if(!isWasmInitialized) {
3326 throw new Error("initializeWasm() must be awaited first!");
3328 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
3329 return nativeResponseValue;
3331 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
3333 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
3334 if(!isWasmInitialized) {
3335 throw new Error("initializeWasm() must be awaited first!");
3337 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
3338 return nativeResponseValue;
3340 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
3342 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
3343 if(!isWasmInitialized) {
3344 throw new Error("initializeWasm() must be awaited first!");
3346 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
3347 return nativeResponseValue;
3349 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
3351 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
3352 if(!isWasmInitialized) {
3353 throw new Error("initializeWasm() must be awaited first!");
3355 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
3356 return nativeResponseValue;
3358 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
3360 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
3361 if(!isWasmInitialized) {
3362 throw new Error("initializeWasm() must be awaited first!");
3364 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
3365 return nativeResponseValue;
3367 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
3369 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
3370 if(!isWasmInitialized) {
3371 throw new Error("initializeWasm() must be awaited first!");
3373 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
3374 return nativeResponseValue;
3376 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
3378 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
3379 if(!isWasmInitialized) {
3380 throw new Error("initializeWasm() must be awaited first!");
3382 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
3383 return nativeResponseValue;
3385 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
3387 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
3388 if(!isWasmInitialized) {
3389 throw new Error("initializeWasm() must be awaited first!");
3391 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
3392 return nativeResponseValue;
3394 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
3396 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
3401 return nativeResponseValue;
3403 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
3405 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
3406 if(!isWasmInitialized) {
3407 throw new Error("initializeWasm() must be awaited first!");
3409 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
3410 return nativeResponseValue;
3412 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
3414 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
3415 if(!isWasmInitialized) {
3416 throw new Error("initializeWasm() must be awaited first!");
3418 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
3419 return nativeResponseValue;
3421 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
3423 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
3424 if(!isWasmInitialized) {
3425 throw new Error("initializeWasm() must be awaited first!");
3427 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
3428 return nativeResponseValue;
3430 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3432 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3433 if(!isWasmInitialized) {
3434 throw new Error("initializeWasm() must be awaited first!");
3436 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
3437 return nativeResponseValue;
3439 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3441 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
3442 if(!isWasmInitialized) {
3443 throw new Error("initializeWasm() must be awaited first!");
3445 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
3446 return nativeResponseValue;
3448 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3450 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3451 if(!isWasmInitialized) {
3452 throw new Error("initializeWasm() must be awaited first!");
3454 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
3455 return nativeResponseValue;
3457 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3459 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
3460 if(!isWasmInitialized) {
3461 throw new Error("initializeWasm() must be awaited first!");
3463 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
3464 return nativeResponseValue;
3466 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3468 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
3469 if(!isWasmInitialized) {
3470 throw new Error("initializeWasm() must be awaited first!");
3472 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
3473 return nativeResponseValue;
3475 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3477 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
3478 if(!isWasmInitialized) {
3479 throw new Error("initializeWasm() must be awaited first!");
3481 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
3482 return nativeResponseValue;
3484 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3486 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
3487 if(!isWasmInitialized) {
3488 throw new Error("initializeWasm() must be awaited first!");
3490 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
3491 return nativeResponseValue;
3493 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
3495 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
3496 if(!isWasmInitialized) {
3497 throw new Error("initializeWasm() must be awaited first!");
3499 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
3500 return nativeResponseValue;
3502 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
3504 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
3505 if(!isWasmInitialized) {
3506 throw new Error("initializeWasm() must be awaited first!");
3508 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
3509 return nativeResponseValue;
3511 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
3513 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
3514 if(!isWasmInitialized) {
3515 throw new Error("initializeWasm() must be awaited first!");
3517 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
3518 return nativeResponseValue;
3520 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3522 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3523 if(!isWasmInitialized) {
3524 throw new Error("initializeWasm() must be awaited first!");
3526 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
3527 return nativeResponseValue;
3529 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3531 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
3532 if(!isWasmInitialized) {
3533 throw new Error("initializeWasm() must be awaited first!");
3535 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
3536 return nativeResponseValue;
3538 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3540 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
3541 if(!isWasmInitialized) {
3542 throw new Error("initializeWasm() must be awaited first!");
3544 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
3545 return nativeResponseValue;
3547 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
3549 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
3550 if(!isWasmInitialized) {
3551 throw new Error("initializeWasm() must be awaited first!");
3553 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
3554 return nativeResponseValue;
3556 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
3558 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
3559 if(!isWasmInitialized) {
3560 throw new Error("initializeWasm() must be awaited first!");
3562 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
3563 return nativeResponseValue;
3565 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
3567 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
3568 if(!isWasmInitialized) {
3569 throw new Error("initializeWasm() must be awaited first!");
3571 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
3572 return nativeResponseValue;
3574 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
3576 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
3577 if(!isWasmInitialized) {
3578 throw new Error("initializeWasm() must be awaited first!");
3580 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
3581 return nativeResponseValue;
3583 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
3585 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
3586 if(!isWasmInitialized) {
3587 throw new Error("initializeWasm() must be awaited first!");
3589 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
3590 return nativeResponseValue;
3592 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3594 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
3595 if(!isWasmInitialized) {
3596 throw new Error("initializeWasm() must be awaited first!");
3598 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
3599 return nativeResponseValue;
3601 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3603 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
3604 if(!isWasmInitialized) {
3605 throw new Error("initializeWasm() must be awaited first!");
3607 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
3608 return nativeResponseValue;
3610 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3612 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
3613 if(!isWasmInitialized) {
3614 throw new Error("initializeWasm() must be awaited first!");
3616 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
3617 return nativeResponseValue;
3619 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
3621 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
3622 if(!isWasmInitialized) {
3623 throw new Error("initializeWasm() must be awaited first!");
3625 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
3626 return nativeResponseValue;
3628 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
3630 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
3631 if(!isWasmInitialized) {
3632 throw new Error("initializeWasm() must be awaited first!");
3634 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
3635 return nativeResponseValue;
3637 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
3639 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
3640 if(!isWasmInitialized) {
3641 throw new Error("initializeWasm() must be awaited first!");
3643 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
3644 return nativeResponseValue;
3646 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3648 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3649 if(!isWasmInitialized) {
3650 throw new Error("initializeWasm() must be awaited first!");
3652 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3653 return nativeResponseValue;
3655 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3657 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3658 if(!isWasmInitialized) {
3659 throw new Error("initializeWasm() must be awaited first!");
3661 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3662 return nativeResponseValue;
3664 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3666 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3667 if(!isWasmInitialized) {
3668 throw new Error("initializeWasm() must be awaited first!");
3670 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3671 return nativeResponseValue;
3673 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3675 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3676 if(!isWasmInitialized) {
3677 throw new Error("initializeWasm() must be awaited first!");
3679 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3680 return nativeResponseValue;
3682 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3684 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3685 if(!isWasmInitialized) {
3686 throw new Error("initializeWasm() must be awaited first!");
3688 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3689 return nativeResponseValue;
3691 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3693 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3694 if(!isWasmInitialized) {
3695 throw new Error("initializeWasm() must be awaited first!");
3697 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3698 return nativeResponseValue;
3700 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3702 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3703 if(!isWasmInitialized) {
3704 throw new Error("initializeWasm() must be awaited first!");
3706 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3707 return nativeResponseValue;
3709 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3711 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3716 return nativeResponseValue;
3718 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3720 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3721 if(!isWasmInitialized) {
3722 throw new Error("initializeWasm() must be awaited first!");
3724 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3725 return nativeResponseValue;
3727 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3729 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3730 if(!isWasmInitialized) {
3731 throw new Error("initializeWasm() must be awaited first!");
3733 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3734 // debug statements here
3736 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3738 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3739 if(!isWasmInitialized) {
3740 throw new Error("initializeWasm() must be awaited first!");
3742 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3743 return nativeResponseValue;
3745 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3747 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3748 if(!isWasmInitialized) {
3749 throw new Error("initializeWasm() must be awaited first!");
3751 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3752 // debug statements here
3754 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3756 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3757 if(!isWasmInitialized) {
3758 throw new Error("initializeWasm() must be awaited first!");
3760 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3761 return nativeResponseValue;
3763 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3765 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3766 if(!isWasmInitialized) {
3767 throw new Error("initializeWasm() must be awaited first!");
3769 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3770 return nativeResponseValue;
3772 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3774 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3775 if(!isWasmInitialized) {
3776 throw new Error("initializeWasm() must be awaited first!");
3778 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3779 return nativeResponseValue;
3781 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3783 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3784 if(!isWasmInitialized) {
3785 throw new Error("initializeWasm() must be awaited first!");
3787 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3788 // debug statements here
3791 export interface LDKFilter {
3792 register_tx (txid: number, script_pubkey: number): void;
3793 register_output (output: number): number;
3797 export function LDKFilter_new(impl: LDKFilter): number {
3798 if(!isWasmInitialized) {
3799 throw new Error("initializeWasm() must be awaited first!");
3801 var new_obj_idx = js_objs.length;
3802 for (var i = 0; i < js_objs.length; i++) {
3803 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3805 js_objs[i] = new WeakRef(impl);
3806 return wasm.TS_LDKFilter_new(i);
3808 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
3810 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
3811 if(!isWasmInitialized) {
3812 throw new Error("initializeWasm() must be awaited first!");
3814 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
3815 // debug statements here
3817 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
3819 export function Filter_register_output(this_arg: number, output: number): number {
3820 if(!isWasmInitialized) {
3821 throw new Error("initializeWasm() must be awaited first!");
3823 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
3824 return nativeResponseValue;
3827 export class LDKCOption_FilterZ {
3828 protected constructor() {}
3831 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
3832 if(!isWasmInitialized) {
3833 throw new Error("initializeWasm() must be awaited first!");
3835 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
3836 return nativeResponseValue;
3839 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
3840 if(!isWasmInitialized) {
3841 throw new Error("initializeWasm() must be awaited first!");
3843 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
3844 return nativeResponseValue;
3846 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
3848 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
3849 if(!isWasmInitialized) {
3850 throw new Error("initializeWasm() must be awaited first!");
3852 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
3853 return nativeResponseValue;
3855 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
3857 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
3858 if(!isWasmInitialized) {
3859 throw new Error("initializeWasm() must be awaited first!");
3861 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
3862 // debug statements here
3865 export class LDKAPIError {
3866 protected constructor() {}
3869 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3870 if(!isWasmInitialized) {
3871 throw new Error("initializeWasm() must be awaited first!");
3873 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3874 return nativeResponseValue;
3877 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3878 if(!isWasmInitialized) {
3879 throw new Error("initializeWasm() must be awaited first!");
3881 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3882 return nativeResponseValue;
3885 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3886 if(!isWasmInitialized) {
3887 throw new Error("initializeWasm() must be awaited first!");
3889 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3890 return nativeResponseValue;
3893 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3894 if(!isWasmInitialized) {
3895 throw new Error("initializeWasm() must be awaited first!");
3897 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3898 return nativeResponseValue;
3901 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3902 if(!isWasmInitialized) {
3903 throw new Error("initializeWasm() must be awaited first!");
3905 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3906 return nativeResponseValue;
3909 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3910 if(!isWasmInitialized) {
3911 throw new Error("initializeWasm() must be awaited first!");
3913 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3914 return nativeResponseValue;
3917 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3918 if(!isWasmInitialized) {
3919 throw new Error("initializeWasm() must be awaited first!");
3921 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3922 return nativeResponseValue;
3924 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3926 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3927 if(!isWasmInitialized) {
3928 throw new Error("initializeWasm() must be awaited first!");
3930 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3931 // debug statements here
3933 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3935 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3936 if(!isWasmInitialized) {
3937 throw new Error("initializeWasm() must be awaited first!");
3939 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3940 return nativeResponseValue;
3943 export class LDKCOption_u16Z {
3944 protected constructor() {}
3947 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3948 if(!isWasmInitialized) {
3949 throw new Error("initializeWasm() must be awaited first!");
3951 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3952 return nativeResponseValue;
3955 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3956 if(!isWasmInitialized) {
3957 throw new Error("initializeWasm() must be awaited first!");
3959 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3960 return nativeResponseValue;
3962 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3964 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3965 if(!isWasmInitialized) {
3966 throw new Error("initializeWasm() must be awaited first!");
3968 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3969 return nativeResponseValue;
3971 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3973 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3974 if(!isWasmInitialized) {
3975 throw new Error("initializeWasm() must be awaited first!");
3977 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3978 return nativeResponseValue;
3981 export class LDKPaymentSendFailure {
3982 protected constructor() {}
3985 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3986 if(!isWasmInitialized) {
3987 throw new Error("initializeWasm() must be awaited first!");
3989 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3990 return nativeResponseValue;
3993 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3994 if(!isWasmInitialized) {
3995 throw new Error("initializeWasm() must be awaited first!");
3997 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3998 return nativeResponseValue;
4001 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
4002 if(!isWasmInitialized) {
4003 throw new Error("initializeWasm() must be awaited first!");
4005 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
4006 return nativeResponseValue;
4009 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
4010 if(!isWasmInitialized) {
4011 throw new Error("initializeWasm() must be awaited first!");
4013 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
4014 return nativeResponseValue;
4017 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
4018 if(!isWasmInitialized) {
4019 throw new Error("initializeWasm() must be awaited first!");
4021 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
4022 return nativeResponseValue;
4025 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
4026 if(!isWasmInitialized) {
4027 throw new Error("initializeWasm() must be awaited first!");
4029 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
4030 return nativeResponseValue;
4033 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
4034 if(!isWasmInitialized) {
4035 throw new Error("initializeWasm() must be awaited first!");
4037 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
4038 return nativeResponseValue;
4040 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
4042 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
4043 if(!isWasmInitialized) {
4044 throw new Error("initializeWasm() must be awaited first!");
4046 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
4047 return nativeResponseValue;
4049 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
4051 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
4052 if(!isWasmInitialized) {
4053 throw new Error("initializeWasm() must be awaited first!");
4055 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
4056 return nativeResponseValue;
4058 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4060 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
4061 if(!isWasmInitialized) {
4062 throw new Error("initializeWasm() must be awaited first!");
4064 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
4065 // debug statements here
4067 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
4069 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
4070 if(!isWasmInitialized) {
4071 throw new Error("initializeWasm() must be awaited first!");
4073 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
4074 return nativeResponseValue;
4076 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4078 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
4079 if(!isWasmInitialized) {
4080 throw new Error("initializeWasm() must be awaited first!");
4082 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
4083 return nativeResponseValue;
4085 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
4087 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
4092 return nativeResponseValue;
4094 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4096 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
4097 if(!isWasmInitialized) {
4098 throw new Error("initializeWasm() must be awaited first!");
4100 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
4101 return nativeResponseValue;
4103 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
4105 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
4106 if(!isWasmInitialized) {
4107 throw new Error("initializeWasm() must be awaited first!");
4109 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
4110 return nativeResponseValue;
4112 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4114 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
4115 if(!isWasmInitialized) {
4116 throw new Error("initializeWasm() must be awaited first!");
4118 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
4119 return nativeResponseValue;
4121 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
4123 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
4124 if(!isWasmInitialized) {
4125 throw new Error("initializeWasm() must be awaited first!");
4127 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
4128 return nativeResponseValue;
4130 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4132 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
4133 if(!isWasmInitialized) {
4134 throw new Error("initializeWasm() must be awaited first!");
4136 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
4137 return nativeResponseValue;
4139 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
4141 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
4142 if(!isWasmInitialized) {
4143 throw new Error("initializeWasm() must be awaited first!");
4145 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
4146 // debug statements here
4148 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4150 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
4151 if(!isWasmInitialized) {
4152 throw new Error("initializeWasm() must be awaited first!");
4154 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
4155 return nativeResponseValue;
4157 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
4159 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
4160 if(!isWasmInitialized) {
4161 throw new Error("initializeWasm() must be awaited first!");
4163 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
4164 return nativeResponseValue;
4166 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4168 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
4169 if(!isWasmInitialized) {
4170 throw new Error("initializeWasm() must be awaited first!");
4172 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
4173 return nativeResponseValue;
4175 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
4177 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
4178 if(!isWasmInitialized) {
4179 throw new Error("initializeWasm() must be awaited first!");
4181 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
4182 // debug statements here
4184 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4186 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
4187 if(!isWasmInitialized) {
4188 throw new Error("initializeWasm() must be awaited first!");
4190 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
4191 return nativeResponseValue;
4193 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
4195 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
4196 if(!isWasmInitialized) {
4197 throw new Error("initializeWasm() must be awaited first!");
4199 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
4200 return nativeResponseValue;
4202 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4204 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
4205 if(!isWasmInitialized) {
4206 throw new Error("initializeWasm() must be awaited first!");
4208 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
4209 return nativeResponseValue;
4211 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
4213 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
4214 if(!isWasmInitialized) {
4215 throw new Error("initializeWasm() must be awaited first!");
4217 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
4218 return nativeResponseValue;
4221 export interface LDKWatch {
4222 watch_channel (funding_txo: number, monitor: number): number;
4223 update_channel (funding_txo: number, update: number): number;
4224 release_pending_monitor_events (): number;
4228 export function LDKWatch_new(impl: LDKWatch): number {
4229 if(!isWasmInitialized) {
4230 throw new Error("initializeWasm() must be awaited first!");
4232 var new_obj_idx = js_objs.length;
4233 for (var i = 0; i < js_objs.length; i++) {
4234 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4236 js_objs[i] = new WeakRef(impl);
4237 return wasm.TS_LDKWatch_new(i);
4239 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
4241 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
4242 if(!isWasmInitialized) {
4243 throw new Error("initializeWasm() must be awaited first!");
4245 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
4246 return nativeResponseValue;
4248 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
4250 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
4251 if(!isWasmInitialized) {
4252 throw new Error("initializeWasm() must be awaited first!");
4254 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
4255 return nativeResponseValue;
4257 // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
4259 export function Watch_release_pending_monitor_events(this_arg: number): number {
4260 if(!isWasmInitialized) {
4261 throw new Error("initializeWasm() must be awaited first!");
4263 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
4264 return nativeResponseValue;
4267 export interface LDKBroadcasterInterface {
4268 broadcast_transaction (tx: number): void;
4272 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
4273 if(!isWasmInitialized) {
4274 throw new Error("initializeWasm() must be awaited first!");
4276 var new_obj_idx = js_objs.length;
4277 for (var i = 0; i < js_objs.length; i++) {
4278 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4280 js_objs[i] = new WeakRef(impl);
4281 return wasm.TS_LDKBroadcasterInterface_new(i);
4283 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
4285 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
4286 if(!isWasmInitialized) {
4287 throw new Error("initializeWasm() must be awaited first!");
4289 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
4290 // debug statements here
4293 export interface LDKKeysInterface {
4294 get_node_secret (): number;
4295 get_destination_script (): number;
4296 get_shutdown_scriptpubkey (): number;
4297 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
4298 get_secure_random_bytes (): number;
4299 read_chan_signer (reader: number): number;
4300 sign_invoice (invoice_preimage: number): number;
4301 get_inbound_payment_key_material (): number;
4305 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
4306 if(!isWasmInitialized) {
4307 throw new Error("initializeWasm() must be awaited first!");
4309 var new_obj_idx = js_objs.length;
4310 for (var i = 0; i < js_objs.length; i++) {
4311 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4313 js_objs[i] = new WeakRef(impl);
4314 return wasm.TS_LDKKeysInterface_new(i);
4316 // LDKSecretKey KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg
4318 export function KeysInterface_get_node_secret(this_arg: number): number {
4319 if(!isWasmInitialized) {
4320 throw new Error("initializeWasm() must be awaited first!");
4322 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg);
4323 return nativeResponseValue;
4325 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4327 export function KeysInterface_get_destination_script(this_arg: number): number {
4328 if(!isWasmInitialized) {
4329 throw new Error("initializeWasm() must be awaited first!");
4331 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4332 return nativeResponseValue;
4334 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4336 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
4337 if(!isWasmInitialized) {
4338 throw new Error("initializeWasm() must be awaited first!");
4340 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4341 return nativeResponseValue;
4343 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4345 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
4346 if(!isWasmInitialized) {
4347 throw new Error("initializeWasm() must be awaited first!");
4349 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4350 return nativeResponseValue;
4352 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4354 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
4355 if(!isWasmInitialized) {
4356 throw new Error("initializeWasm() must be awaited first!");
4358 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4359 return nativeResponseValue;
4361 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4363 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
4364 if(!isWasmInitialized) {
4365 throw new Error("initializeWasm() must be awaited first!");
4367 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4368 return nativeResponseValue;
4370 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKCVec_u8Z invoice_preimage
4372 export function KeysInterface_sign_invoice(this_arg: number, invoice_preimage: number): number {
4373 if(!isWasmInitialized) {
4374 throw new Error("initializeWasm() must be awaited first!");
4376 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, invoice_preimage);
4377 return nativeResponseValue;
4379 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4381 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4386 return nativeResponseValue;
4389 export interface LDKFeeEstimator {
4390 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4394 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
4395 if(!isWasmInitialized) {
4396 throw new Error("initializeWasm() must be awaited first!");
4398 var new_obj_idx = js_objs.length;
4399 for (var i = 0; i < js_objs.length; i++) {
4400 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4402 js_objs[i] = new WeakRef(impl);
4403 return wasm.TS_LDKFeeEstimator_new(i);
4405 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4407 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
4408 if(!isWasmInitialized) {
4409 throw new Error("initializeWasm() must be awaited first!");
4411 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4412 return nativeResponseValue;
4415 export interface LDKLogger {
4416 log (record: number): void;
4420 export function LDKLogger_new(impl: LDKLogger): number {
4421 if(!isWasmInitialized) {
4422 throw new Error("initializeWasm() must be awaited first!");
4424 var new_obj_idx = js_objs.length;
4425 for (var i = 0; i < js_objs.length; i++) {
4426 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4428 js_objs[i] = new WeakRef(impl);
4429 return wasm.TS_LDKLogger_new(i);
4431 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4433 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
4434 if(!isWasmInitialized) {
4435 throw new Error("initializeWasm() must be awaited first!");
4437 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4438 return nativeResponseValue;
4440 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4442 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
4443 if(!isWasmInitialized) {
4444 throw new Error("initializeWasm() must be awaited first!");
4446 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4447 return nativeResponseValue;
4449 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4451 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
4452 if(!isWasmInitialized) {
4453 throw new Error("initializeWasm() must be awaited first!");
4455 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4456 return nativeResponseValue;
4458 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4460 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
4461 if(!isWasmInitialized) {
4462 throw new Error("initializeWasm() must be awaited first!");
4464 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4465 return nativeResponseValue;
4468 export interface LDKMessageSendEventsProvider {
4469 get_and_clear_pending_msg_events (): number;
4473 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
4474 if(!isWasmInitialized) {
4475 throw new Error("initializeWasm() must be awaited first!");
4477 var new_obj_idx = js_objs.length;
4478 for (var i = 0; i < js_objs.length; i++) {
4479 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4481 js_objs[i] = new WeakRef(impl);
4482 return wasm.TS_LDKMessageSendEventsProvider_new(i);
4484 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
4486 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
4487 if(!isWasmInitialized) {
4488 throw new Error("initializeWasm() must be awaited first!");
4490 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
4491 return nativeResponseValue;
4494 export interface LDKEventHandler {
4495 handle_event (event: number): void;
4499 export function LDKEventHandler_new(impl: LDKEventHandler): number {
4500 if(!isWasmInitialized) {
4501 throw new Error("initializeWasm() must be awaited first!");
4503 var new_obj_idx = js_objs.length;
4504 for (var i = 0; i < js_objs.length; i++) {
4505 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4507 js_objs[i] = new WeakRef(impl);
4508 return wasm.TS_LDKEventHandler_new(i);
4510 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
4512 export function EventHandler_handle_event(this_arg: number, event: number): void {
4513 if(!isWasmInitialized) {
4514 throw new Error("initializeWasm() must be awaited first!");
4516 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
4517 // debug statements here
4520 export interface LDKEventsProvider {
4521 process_pending_events (handler: number): void;
4525 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
4526 if(!isWasmInitialized) {
4527 throw new Error("initializeWasm() must be awaited first!");
4529 var new_obj_idx = js_objs.length;
4530 for (var i = 0; i < js_objs.length; i++) {
4531 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4533 js_objs[i] = new WeakRef(impl);
4534 return wasm.TS_LDKEventsProvider_new(i);
4536 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
4538 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
4539 if(!isWasmInitialized) {
4540 throw new Error("initializeWasm() must be awaited first!");
4542 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
4543 // debug statements here
4546 export interface LDKListen {
4547 block_connected (block: number, height: number): void;
4548 block_disconnected (header: number, height: number): void;
4552 export function LDKListen_new(impl: LDKListen): number {
4553 if(!isWasmInitialized) {
4554 throw new Error("initializeWasm() must be awaited first!");
4556 var new_obj_idx = js_objs.length;
4557 for (var i = 0; i < js_objs.length; i++) {
4558 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4560 js_objs[i] = new WeakRef(impl);
4561 return wasm.TS_LDKListen_new(i);
4563 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
4565 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
4566 if(!isWasmInitialized) {
4567 throw new Error("initializeWasm() must be awaited first!");
4569 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
4570 // debug statements here
4572 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
4574 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
4575 if(!isWasmInitialized) {
4576 throw new Error("initializeWasm() must be awaited first!");
4578 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
4579 // debug statements here
4582 export interface LDKConfirm {
4583 transactions_confirmed (header: number, txdata: number, height: number): void;
4584 transaction_unconfirmed (txid: number): void;
4585 best_block_updated (header: number, height: number): void;
4586 get_relevant_txids (): number;
4590 export function LDKConfirm_new(impl: LDKConfirm): number {
4591 if(!isWasmInitialized) {
4592 throw new Error("initializeWasm() must be awaited first!");
4594 var new_obj_idx = js_objs.length;
4595 for (var i = 0; i < js_objs.length; i++) {
4596 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4598 js_objs[i] = new WeakRef(impl);
4599 return wasm.TS_LDKConfirm_new(i);
4601 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
4603 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
4604 if(!isWasmInitialized) {
4605 throw new Error("initializeWasm() must be awaited first!");
4607 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
4608 // debug statements here
4610 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
4612 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
4613 if(!isWasmInitialized) {
4614 throw new Error("initializeWasm() must be awaited first!");
4616 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
4617 // debug statements here
4619 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
4621 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
4622 if(!isWasmInitialized) {
4623 throw new Error("initializeWasm() must be awaited first!");
4625 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
4626 // debug statements here
4628 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
4630 export function Confirm_get_relevant_txids(this_arg: number): number {
4631 if(!isWasmInitialized) {
4632 throw new Error("initializeWasm() must be awaited first!");
4634 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
4635 return nativeResponseValue;
4638 export interface LDKPersist {
4639 persist_new_channel (channel_id: number, data: number, update_id: number): number;
4640 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
4644 export function LDKPersist_new(impl: LDKPersist): number {
4645 if(!isWasmInitialized) {
4646 throw new Error("initializeWasm() must be awaited first!");
4648 var new_obj_idx = js_objs.length;
4649 for (var i = 0; i < js_objs.length; i++) {
4650 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4652 js_objs[i] = new WeakRef(impl);
4653 return wasm.TS_LDKPersist_new(i);
4655 // 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
4657 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
4658 if(!isWasmInitialized) {
4659 throw new Error("initializeWasm() must be awaited first!");
4661 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
4662 return nativeResponseValue;
4664 // 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
4666 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
4667 if(!isWasmInitialized) {
4668 throw new Error("initializeWasm() must be awaited first!");
4670 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
4671 return nativeResponseValue;
4674 export interface LDKChannelMessageHandler {
4675 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
4676 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
4677 handle_funding_created (their_node_id: number, msg: number): void;
4678 handle_funding_signed (their_node_id: number, msg: number): void;
4679 handle_funding_locked (their_node_id: number, msg: number): void;
4680 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
4681 handle_closing_signed (their_node_id: number, msg: number): void;
4682 handle_update_add_htlc (their_node_id: number, msg: number): void;
4683 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
4684 handle_update_fail_htlc (their_node_id: number, msg: number): void;
4685 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
4686 handle_commitment_signed (their_node_id: number, msg: number): void;
4687 handle_revoke_and_ack (their_node_id: number, msg: number): void;
4688 handle_update_fee (their_node_id: number, msg: number): void;
4689 handle_announcement_signatures (their_node_id: number, msg: number): void;
4690 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
4691 peer_connected (their_node_id: number, msg: number): void;
4692 handle_channel_reestablish (their_node_id: number, msg: number): void;
4693 handle_channel_update (their_node_id: number, msg: number): void;
4694 handle_error (their_node_id: number, msg: number): void;
4698 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
4699 if(!isWasmInitialized) {
4700 throw new Error("initializeWasm() must be awaited first!");
4702 var new_obj_idx = js_objs.length;
4703 for (var i = 0; i < js_objs.length; i++) {
4704 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4706 js_objs[i] = new WeakRef(impl);
4707 return wasm.TS_LDKChannelMessageHandler_new(i);
4709 // 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
4711 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
4712 if(!isWasmInitialized) {
4713 throw new Error("initializeWasm() must be awaited first!");
4715 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
4716 // debug statements here
4718 // 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
4720 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
4721 if(!isWasmInitialized) {
4722 throw new Error("initializeWasm() must be awaited first!");
4724 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
4725 // debug statements here
4727 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
4729 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
4730 if(!isWasmInitialized) {
4731 throw new Error("initializeWasm() must be awaited first!");
4733 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
4734 // debug statements here
4736 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
4738 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
4739 if(!isWasmInitialized) {
4740 throw new Error("initializeWasm() must be awaited first!");
4742 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
4743 // debug statements here
4745 // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
4747 export function ChannelMessageHandler_handle_funding_locked(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_locked(this_arg, their_node_id, msg);
4752 // debug statements here
4754 // 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
4756 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
4757 if(!isWasmInitialized) {
4758 throw new Error("initializeWasm() must be awaited first!");
4760 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
4761 // debug statements here
4763 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
4765 export function ChannelMessageHandler_handle_closing_signed(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_closing_signed(this_arg, their_node_id, msg);
4770 // debug statements here
4772 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
4774 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
4775 if(!isWasmInitialized) {
4776 throw new Error("initializeWasm() must be awaited first!");
4778 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
4779 // debug statements here
4781 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
4783 export function ChannelMessageHandler_handle_update_fulfill_htlc(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_update_fulfill_htlc(this_arg, their_node_id, msg);
4788 // debug statements here
4790 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
4792 export function ChannelMessageHandler_handle_update_fail_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_fail_htlc(this_arg, their_node_id, msg);
4797 // debug statements here
4799 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
4801 export function ChannelMessageHandler_handle_update_fail_malformed_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_fail_malformed_htlc(this_arg, their_node_id, msg);
4806 // debug statements here
4808 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
4810 export function ChannelMessageHandler_handle_commitment_signed(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_commitment_signed(this_arg, their_node_id, msg);
4815 // debug statements here
4817 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
4819 export function ChannelMessageHandler_handle_revoke_and_ack(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_revoke_and_ack(this_arg, their_node_id, msg);
4824 // debug statements here
4826 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
4828 export function ChannelMessageHandler_handle_update_fee(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_update_fee(this_arg, their_node_id, msg);
4833 // debug statements here
4835 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
4837 export function ChannelMessageHandler_handle_announcement_signatures(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_announcement_signatures(this_arg, their_node_id, msg);
4842 // debug statements here
4844 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
4846 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
4847 if(!isWasmInitialized) {
4848 throw new Error("initializeWasm() must be awaited first!");
4850 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
4851 // debug statements here
4853 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
4855 export function ChannelMessageHandler_peer_connected(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_peer_connected(this_arg, their_node_id, msg);
4860 // debug statements here
4862 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
4864 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
4865 if(!isWasmInitialized) {
4866 throw new Error("initializeWasm() must be awaited first!");
4868 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
4869 // debug statements here
4871 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
4873 export function ChannelMessageHandler_handle_channel_update(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_handle_channel_update(this_arg, their_node_id, msg);
4878 // debug statements here
4880 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
4882 export function ChannelMessageHandler_handle_error(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_error(this_arg, their_node_id, msg);
4887 // debug statements here
4890 export interface LDKRoutingMessageHandler {
4891 handle_node_announcement (msg: number): number;
4892 handle_channel_announcement (msg: number): number;
4893 handle_channel_update (msg: number): number;
4894 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
4895 get_next_node_announcements (starting_point: number, batch_amount: number): number;
4896 sync_routing_table (their_node_id: number, init: number): void;
4897 handle_reply_channel_range (their_node_id: number, msg: number): number;
4898 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
4899 handle_query_channel_range (their_node_id: number, msg: number): number;
4900 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
4904 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
4905 if(!isWasmInitialized) {
4906 throw new Error("initializeWasm() must be awaited first!");
4908 var new_obj_idx = js_objs.length;
4909 for (var i = 0; i < js_objs.length; i++) {
4910 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4912 js_objs[i] = new WeakRef(impl);
4913 return wasm.TS_LDKRoutingMessageHandler_new(i);
4915 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
4917 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
4918 if(!isWasmInitialized) {
4919 throw new Error("initializeWasm() must be awaited first!");
4921 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
4922 return nativeResponseValue;
4924 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
4926 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
4927 if(!isWasmInitialized) {
4928 throw new Error("initializeWasm() must be awaited first!");
4930 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
4931 return nativeResponseValue;
4933 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
4935 export function RoutingMessageHandler_handle_channel_update(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_channel_update(this_arg, msg);
4940 return nativeResponseValue;
4942 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
4944 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
4945 if(!isWasmInitialized) {
4946 throw new Error("initializeWasm() must be awaited first!");
4948 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
4949 return nativeResponseValue;
4951 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
4953 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
4954 if(!isWasmInitialized) {
4955 throw new Error("initializeWasm() must be awaited first!");
4957 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
4958 return nativeResponseValue;
4960 // void RoutingMessageHandler_sync_routing_table LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
4962 export function RoutingMessageHandler_sync_routing_table(this_arg: number, their_node_id: number, init: number): void {
4963 if(!isWasmInitialized) {
4964 throw new Error("initializeWasm() must be awaited first!");
4966 const nativeResponseValue = wasm.TS_RoutingMessageHandler_sync_routing_table(this_arg, their_node_id, init);
4967 // debug statements here
4969 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
4971 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
4972 if(!isWasmInitialized) {
4973 throw new Error("initializeWasm() must be awaited first!");
4975 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
4976 return nativeResponseValue;
4978 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
4980 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
4981 if(!isWasmInitialized) {
4982 throw new Error("initializeWasm() must be awaited first!");
4984 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
4985 return nativeResponseValue;
4987 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
4989 export function RoutingMessageHandler_handle_query_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_query_channel_range(this_arg, their_node_id, msg);
4994 return nativeResponseValue;
4996 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
4998 export function RoutingMessageHandler_handle_query_short_channel_ids(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_query_short_channel_ids(this_arg, their_node_id, msg);
5003 return nativeResponseValue;
5006 export interface LDKCustomMessageReader {
5007 read (message_type: number, buffer: number): number;
5011 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
5012 if(!isWasmInitialized) {
5013 throw new Error("initializeWasm() must be awaited first!");
5015 var new_obj_idx = js_objs.length;
5016 for (var i = 0; i < js_objs.length; i++) {
5017 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5019 js_objs[i] = new WeakRef(impl);
5020 return wasm.TS_LDKCustomMessageReader_new(i);
5022 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
5024 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
5025 if(!isWasmInitialized) {
5026 throw new Error("initializeWasm() must be awaited first!");
5028 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
5029 return nativeResponseValue;
5032 export interface LDKCustomMessageHandler {
5033 handle_custom_message (msg: number, sender_node_id: number): number;
5034 get_and_clear_pending_msg (): number;
5038 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
5039 if(!isWasmInitialized) {
5040 throw new Error("initializeWasm() must be awaited first!");
5042 var new_obj_idx = js_objs.length;
5043 for (var i = 0; i < js_objs.length; i++) {
5044 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5046 js_objs[i] = new WeakRef(impl);
5047 return wasm.TS_LDKCustomMessageHandler_new(i);
5049 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
5051 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
5052 if(!isWasmInitialized) {
5053 throw new Error("initializeWasm() must be awaited first!");
5055 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
5056 return nativeResponseValue;
5058 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
5060 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
5061 if(!isWasmInitialized) {
5062 throw new Error("initializeWasm() must be awaited first!");
5064 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
5065 return nativeResponseValue;
5068 export interface LDKSocketDescriptor {
5069 send_data (data: number, resume_read: boolean): number;
5070 disconnect_socket (): void;
5071 eq (other_arg: number): boolean;
5076 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
5077 if(!isWasmInitialized) {
5078 throw new Error("initializeWasm() must be awaited first!");
5080 var new_obj_idx = js_objs.length;
5081 for (var i = 0; i < js_objs.length; i++) {
5082 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5084 js_objs[i] = new WeakRef(impl);
5085 return wasm.TS_LDKSocketDescriptor_new(i);
5087 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
5089 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
5090 if(!isWasmInitialized) {
5091 throw new Error("initializeWasm() must be awaited first!");
5093 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
5094 return nativeResponseValue;
5096 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
5098 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
5099 if(!isWasmInitialized) {
5100 throw new Error("initializeWasm() must be awaited first!");
5102 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
5103 // debug statements here
5105 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
5107 export function SocketDescriptor_hash(this_arg: number): bigint {
5108 if(!isWasmInitialized) {
5109 throw new Error("initializeWasm() must be awaited first!");
5111 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
5112 return nativeResponseValue;
5115 export interface LDKScore {
5116 channel_penalty_msat (short_channel_id: bigint, send_amt_msat: bigint, channel_capacity_msat: number, source: number, target: number): bigint;
5117 payment_path_failed (path: number, short_channel_id: bigint): void;
5118 payment_path_successful (path: number): void;
5123 export function LDKScore_new(impl: LDKScore): number {
5124 if(!isWasmInitialized) {
5125 throw new Error("initializeWasm() must be awaited first!");
5127 var new_obj_idx = js_objs.length;
5128 for (var i = 0; i < js_objs.length; i++) {
5129 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5131 js_objs[i] = new WeakRef(impl);
5132 return wasm.TS_LDKScore_new(i);
5134 // 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
5136 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 {
5137 if(!isWasmInitialized) {
5138 throw new Error("initializeWasm() must be awaited first!");
5140 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, send_amt_msat, channel_capacity_msat, source, target);
5141 return nativeResponseValue;
5143 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5145 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5146 if(!isWasmInitialized) {
5147 throw new Error("initializeWasm() must be awaited first!");
5149 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5150 // debug statements here
5152 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5154 export function Score_payment_path_successful(this_arg: number, path: number): void {
5155 if(!isWasmInitialized) {
5156 throw new Error("initializeWasm() must be awaited first!");
5158 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5159 // debug statements here
5161 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5163 export function Score_write(this_arg: number): number {
5164 if(!isWasmInitialized) {
5165 throw new Error("initializeWasm() must be awaited first!");
5167 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5168 return nativeResponseValue;
5171 export interface LDKLockableScore {
5176 export function LDKLockableScore_new(impl: LDKLockableScore): number {
5177 if(!isWasmInitialized) {
5178 throw new Error("initializeWasm() must be awaited first!");
5180 var new_obj_idx = js_objs.length;
5181 for (var i = 0; i < js_objs.length; i++) {
5182 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5184 js_objs[i] = new WeakRef(impl);
5185 return wasm.TS_LDKLockableScore_new(i);
5187 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
5189 export function LockableScore_lock(this_arg: number): number {
5190 if(!isWasmInitialized) {
5191 throw new Error("initializeWasm() must be awaited first!");
5193 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
5194 return nativeResponseValue;
5196 // struct LDKStr _ldk_get_compiled_version(void);
5198 export function _ldk_get_compiled_version(): number {
5199 if(!isWasmInitialized) {
5200 throw new Error("initializeWasm() must be awaited first!");
5202 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
5203 return nativeResponseValue;
5205 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
5207 export function _ldk_c_bindings_get_compiled_version(): number {
5208 if(!isWasmInitialized) {
5209 throw new Error("initializeWasm() must be awaited first!");
5211 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
5212 return nativeResponseValue;
5214 // void Transaction_free(struct LDKTransaction _res);
5216 export function Transaction_free(_res: number): void {
5217 if(!isWasmInitialized) {
5218 throw new Error("initializeWasm() must be awaited first!");
5220 const nativeResponseValue = wasm.TS_Transaction_free(_res);
5221 // debug statements here
5223 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
5225 export function TxOut_new(script_pubkey: number, value: bigint): number {
5226 if(!isWasmInitialized) {
5227 throw new Error("initializeWasm() must be awaited first!");
5229 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
5230 return nativeResponseValue;
5232 // void TxOut_free(struct LDKTxOut _res);
5234 export function TxOut_free(_res: number): void {
5235 if(!isWasmInitialized) {
5236 throw new Error("initializeWasm() must be awaited first!");
5238 const nativeResponseValue = wasm.TS_TxOut_free(_res);
5239 // debug statements here
5241 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
5243 export function TxOut_clone_ptr(arg: number): number {
5244 if(!isWasmInitialized) {
5245 throw new Error("initializeWasm() must be awaited first!");
5247 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
5248 return nativeResponseValue;
5250 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
5252 export function TxOut_clone(orig: number): number {
5253 if(!isWasmInitialized) {
5254 throw new Error("initializeWasm() must be awaited first!");
5256 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
5257 return nativeResponseValue;
5259 // void Str_free(struct LDKStr _res);
5261 export function Str_free(_res: number): void {
5262 if(!isWasmInitialized) {
5263 throw new Error("initializeWasm() must be awaited first!");
5265 const nativeResponseValue = wasm.TS_Str_free(_res);
5266 // debug statements here
5268 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
5270 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
5271 if(!isWasmInitialized) {
5272 throw new Error("initializeWasm() must be awaited first!");
5274 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
5275 return nativeResponseValue;
5277 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
5279 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
5280 if(!isWasmInitialized) {
5281 throw new Error("initializeWasm() must be awaited first!");
5283 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
5284 return nativeResponseValue;
5286 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
5288 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
5289 if(!isWasmInitialized) {
5290 throw new Error("initializeWasm() must be awaited first!");
5292 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
5293 return nativeResponseValue;
5295 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
5297 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
5298 if(!isWasmInitialized) {
5299 throw new Error("initializeWasm() must be awaited first!");
5301 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
5302 // debug statements here
5304 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
5306 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
5307 if(!isWasmInitialized) {
5308 throw new Error("initializeWasm() must be awaited first!");
5310 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
5311 return nativeResponseValue;
5313 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
5315 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
5316 if(!isWasmInitialized) {
5317 throw new Error("initializeWasm() must be awaited first!");
5319 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
5320 return nativeResponseValue;
5322 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
5324 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
5325 if(!isWasmInitialized) {
5326 throw new Error("initializeWasm() must be awaited first!");
5328 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
5329 return nativeResponseValue;
5331 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
5333 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
5334 if(!isWasmInitialized) {
5335 throw new Error("initializeWasm() must be awaited first!");
5337 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
5338 return nativeResponseValue;
5340 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
5342 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
5343 if(!isWasmInitialized) {
5344 throw new Error("initializeWasm() must be awaited first!");
5346 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
5347 return nativeResponseValue;
5349 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
5351 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
5352 if(!isWasmInitialized) {
5353 throw new Error("initializeWasm() must be awaited first!");
5355 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
5356 // debug statements here
5358 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
5360 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
5365 return nativeResponseValue;
5367 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
5369 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
5374 return nativeResponseValue;
5376 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
5378 export function CResult_SecretKeyErrorZ_ok(o: number): number {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
5383 return nativeResponseValue;
5385 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
5387 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
5388 if(!isWasmInitialized) {
5389 throw new Error("initializeWasm() must be awaited first!");
5391 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
5392 return nativeResponseValue;
5394 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
5396 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
5397 if(!isWasmInitialized) {
5398 throw new Error("initializeWasm() must be awaited first!");
5400 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
5401 return nativeResponseValue;
5403 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
5405 export function CResult_SecretKeyErrorZ_free(_res: number): void {
5406 if(!isWasmInitialized) {
5407 throw new Error("initializeWasm() must be awaited first!");
5409 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
5410 // debug statements here
5412 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
5414 export function CResult_PublicKeyErrorZ_ok(o: number): number {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
5419 return nativeResponseValue;
5421 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
5423 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
5428 return nativeResponseValue;
5430 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
5432 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
5433 if(!isWasmInitialized) {
5434 throw new Error("initializeWasm() must be awaited first!");
5436 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
5437 return nativeResponseValue;
5439 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
5441 export function CResult_PublicKeyErrorZ_free(_res: number): void {
5442 if(!isWasmInitialized) {
5443 throw new Error("initializeWasm() must be awaited first!");
5445 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
5446 // debug statements here
5448 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
5450 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
5451 if(!isWasmInitialized) {
5452 throw new Error("initializeWasm() must be awaited first!");
5454 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
5455 return nativeResponseValue;
5457 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
5459 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
5464 return nativeResponseValue;
5466 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
5468 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
5469 if(!isWasmInitialized) {
5470 throw new Error("initializeWasm() must be awaited first!");
5472 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
5473 return nativeResponseValue;
5475 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
5477 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
5478 if(!isWasmInitialized) {
5479 throw new Error("initializeWasm() must be awaited first!");
5481 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
5482 return nativeResponseValue;
5484 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
5486 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
5487 if(!isWasmInitialized) {
5488 throw new Error("initializeWasm() must be awaited first!");
5490 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
5491 return nativeResponseValue;
5493 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
5495 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
5496 if(!isWasmInitialized) {
5497 throw new Error("initializeWasm() must be awaited first!");
5499 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
5500 // debug statements here
5502 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
5504 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
5505 if(!isWasmInitialized) {
5506 throw new Error("initializeWasm() must be awaited first!");
5508 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
5509 return nativeResponseValue;
5511 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
5513 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
5514 if(!isWasmInitialized) {
5515 throw new Error("initializeWasm() must be awaited first!");
5517 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
5518 return nativeResponseValue;
5520 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
5522 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
5523 if(!isWasmInitialized) {
5524 throw new Error("initializeWasm() must be awaited first!");
5526 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
5527 return nativeResponseValue;
5529 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
5531 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
5532 if(!isWasmInitialized) {
5533 throw new Error("initializeWasm() must be awaited first!");
5535 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
5536 return nativeResponseValue;
5538 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
5540 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
5541 if(!isWasmInitialized) {
5542 throw new Error("initializeWasm() must be awaited first!");
5544 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
5545 return nativeResponseValue;
5547 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
5549 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
5550 if(!isWasmInitialized) {
5551 throw new Error("initializeWasm() must be awaited first!");
5553 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
5554 // debug statements here
5556 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
5558 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
5563 return nativeResponseValue;
5565 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
5567 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
5568 if(!isWasmInitialized) {
5569 throw new Error("initializeWasm() must be awaited first!");
5571 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
5572 return nativeResponseValue;
5574 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
5576 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
5577 if(!isWasmInitialized) {
5578 throw new Error("initializeWasm() must be awaited first!");
5580 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
5581 return nativeResponseValue;
5583 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
5585 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
5586 if(!isWasmInitialized) {
5587 throw new Error("initializeWasm() must be awaited first!");
5589 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
5590 return nativeResponseValue;
5592 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
5594 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
5599 return nativeResponseValue;
5601 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
5603 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
5608 // debug statements here
5610 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
5612 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
5617 return nativeResponseValue;
5619 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
5621 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
5622 if(!isWasmInitialized) {
5623 throw new Error("initializeWasm() must be awaited first!");
5625 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
5626 return nativeResponseValue;
5628 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
5630 export function COption_u32Z_some(o: number): number {
5631 if(!isWasmInitialized) {
5632 throw new Error("initializeWasm() must be awaited first!");
5634 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
5635 return nativeResponseValue;
5637 // struct LDKCOption_u32Z COption_u32Z_none(void);
5639 export function COption_u32Z_none(): number {
5640 if(!isWasmInitialized) {
5641 throw new Error("initializeWasm() must be awaited first!");
5643 const nativeResponseValue = wasm.TS_COption_u32Z_none();
5644 return nativeResponseValue;
5646 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
5648 export function COption_u32Z_free(_res: number): void {
5649 if(!isWasmInitialized) {
5650 throw new Error("initializeWasm() must be awaited first!");
5652 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
5653 // debug statements here
5655 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
5657 export function COption_u32Z_clone_ptr(arg: number): number {
5658 if(!isWasmInitialized) {
5659 throw new Error("initializeWasm() must be awaited first!");
5661 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
5662 return nativeResponseValue;
5664 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
5666 export function COption_u32Z_clone(orig: number): number {
5667 if(!isWasmInitialized) {
5668 throw new Error("initializeWasm() must be awaited first!");
5670 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
5671 return nativeResponseValue;
5673 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
5675 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
5676 if(!isWasmInitialized) {
5677 throw new Error("initializeWasm() must be awaited first!");
5679 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
5680 return nativeResponseValue;
5682 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
5684 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
5685 if(!isWasmInitialized) {
5686 throw new Error("initializeWasm() must be awaited first!");
5688 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
5689 return nativeResponseValue;
5691 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
5693 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
5694 if(!isWasmInitialized) {
5695 throw new Error("initializeWasm() must be awaited first!");
5697 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
5698 return nativeResponseValue;
5700 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
5702 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
5703 if(!isWasmInitialized) {
5704 throw new Error("initializeWasm() must be awaited first!");
5706 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
5707 // debug statements here
5709 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
5711 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
5712 if(!isWasmInitialized) {
5713 throw new Error("initializeWasm() must be awaited first!");
5715 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
5716 return nativeResponseValue;
5718 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
5720 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
5721 if(!isWasmInitialized) {
5722 throw new Error("initializeWasm() must be awaited first!");
5724 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
5725 return nativeResponseValue;
5727 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
5729 export function COption_NoneZ_some(): COption_NoneZ {
5730 if(!isWasmInitialized) {
5731 throw new Error("initializeWasm() must be awaited first!");
5733 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
5734 return nativeResponseValue;
5736 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
5738 export function COption_NoneZ_none(): COption_NoneZ {
5739 if(!isWasmInitialized) {
5740 throw new Error("initializeWasm() must be awaited first!");
5742 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
5743 return nativeResponseValue;
5745 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
5747 export function COption_NoneZ_free(_res: COption_NoneZ): void {
5748 if(!isWasmInitialized) {
5749 throw new Error("initializeWasm() must be awaited first!");
5751 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
5752 // debug statements here
5754 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
5756 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
5757 if(!isWasmInitialized) {
5758 throw new Error("initializeWasm() must be awaited first!");
5760 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
5761 return nativeResponseValue;
5763 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5765 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
5766 if(!isWasmInitialized) {
5767 throw new Error("initializeWasm() must be awaited first!");
5769 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
5770 return nativeResponseValue;
5772 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
5774 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
5775 if(!isWasmInitialized) {
5776 throw new Error("initializeWasm() must be awaited first!");
5778 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
5779 return nativeResponseValue;
5781 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
5783 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
5784 if(!isWasmInitialized) {
5785 throw new Error("initializeWasm() must be awaited first!");
5787 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
5788 // debug statements here
5790 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
5792 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
5793 if(!isWasmInitialized) {
5794 throw new Error("initializeWasm() must be awaited first!");
5796 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
5797 return nativeResponseValue;
5799 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5801 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
5806 return nativeResponseValue;
5808 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
5810 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
5811 if(!isWasmInitialized) {
5812 throw new Error("initializeWasm() must be awaited first!");
5814 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
5815 return nativeResponseValue;
5817 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
5819 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
5820 if(!isWasmInitialized) {
5821 throw new Error("initializeWasm() must be awaited first!");
5823 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
5824 return nativeResponseValue;
5826 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
5828 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
5833 return nativeResponseValue;
5835 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
5837 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
5842 // debug statements here
5844 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
5846 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
5847 if(!isWasmInitialized) {
5848 throw new Error("initializeWasm() must be awaited first!");
5850 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
5851 return nativeResponseValue;
5853 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
5855 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
5856 if(!isWasmInitialized) {
5857 throw new Error("initializeWasm() must be awaited first!");
5859 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
5860 return nativeResponseValue;
5862 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
5864 export function CVec_SignatureZ_free(_res: number): void {
5865 if(!isWasmInitialized) {
5866 throw new Error("initializeWasm() must be awaited first!");
5868 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
5869 // debug statements here
5871 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
5873 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
5874 if(!isWasmInitialized) {
5875 throw new Error("initializeWasm() must be awaited first!");
5877 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
5878 return nativeResponseValue;
5880 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5882 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
5887 return nativeResponseValue;
5889 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
5891 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
5896 return nativeResponseValue;
5898 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
5900 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
5905 // debug statements here
5907 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
5909 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
5914 return nativeResponseValue;
5916 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5918 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
5923 return nativeResponseValue;
5925 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
5927 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
5932 return nativeResponseValue;
5934 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
5936 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
5941 return nativeResponseValue;
5943 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
5945 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
5950 return nativeResponseValue;
5952 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
5954 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
5959 // debug statements here
5961 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
5963 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
5968 return nativeResponseValue;
5970 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
5972 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
5977 return nativeResponseValue;
5979 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
5981 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
5986 return nativeResponseValue;
5988 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
5990 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
5995 return nativeResponseValue;
5997 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
5999 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
6004 return nativeResponseValue;
6006 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
6008 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
6013 // debug statements here
6015 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
6017 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
6022 return nativeResponseValue;
6024 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6026 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
6031 return nativeResponseValue;
6033 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6035 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
6040 return nativeResponseValue;
6042 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
6044 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
6049 // debug statements here
6051 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
6053 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
6058 return nativeResponseValue;
6060 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
6062 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
6063 if(!isWasmInitialized) {
6064 throw new Error("initializeWasm() must be awaited first!");
6066 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
6067 return nativeResponseValue;
6069 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
6071 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
6072 if(!isWasmInitialized) {
6073 throw new Error("initializeWasm() must be awaited first!");
6075 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
6076 return nativeResponseValue;
6078 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
6080 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
6081 if(!isWasmInitialized) {
6082 throw new Error("initializeWasm() must be awaited first!");
6084 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
6085 return nativeResponseValue;
6087 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
6089 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
6094 return nativeResponseValue;
6096 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
6098 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
6099 if(!isWasmInitialized) {
6100 throw new Error("initializeWasm() must be awaited first!");
6102 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
6103 // debug statements here
6105 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
6107 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
6108 if(!isWasmInitialized) {
6109 throw new Error("initializeWasm() must be awaited first!");
6111 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
6112 return nativeResponseValue;
6114 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
6116 export function CResult_CVec_SignatureZNoneZ_err(): number {
6117 if(!isWasmInitialized) {
6118 throw new Error("initializeWasm() must be awaited first!");
6120 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
6121 return nativeResponseValue;
6123 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
6125 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
6130 return nativeResponseValue;
6132 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
6134 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
6135 if(!isWasmInitialized) {
6136 throw new Error("initializeWasm() must be awaited first!");
6138 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
6139 // debug statements here
6141 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
6143 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
6144 if(!isWasmInitialized) {
6145 throw new Error("initializeWasm() must be awaited first!");
6147 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
6148 return nativeResponseValue;
6150 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
6152 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
6153 if(!isWasmInitialized) {
6154 throw new Error("initializeWasm() must be awaited first!");
6156 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
6157 return nativeResponseValue;
6159 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
6161 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
6162 if(!isWasmInitialized) {
6163 throw new Error("initializeWasm() must be awaited first!");
6165 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
6166 return nativeResponseValue;
6168 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
6170 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
6171 if(!isWasmInitialized) {
6172 throw new Error("initializeWasm() must be awaited first!");
6174 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
6175 return nativeResponseValue;
6177 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
6179 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
6180 if(!isWasmInitialized) {
6181 throw new Error("initializeWasm() must be awaited first!");
6183 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
6184 return nativeResponseValue;
6186 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
6188 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
6189 if(!isWasmInitialized) {
6190 throw new Error("initializeWasm() must be awaited first!");
6192 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
6193 // debug statements here
6195 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
6197 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
6198 if(!isWasmInitialized) {
6199 throw new Error("initializeWasm() must be awaited first!");
6201 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
6202 return nativeResponseValue;
6204 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
6206 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
6207 if(!isWasmInitialized) {
6208 throw new Error("initializeWasm() must be awaited first!");
6210 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
6211 return nativeResponseValue;
6213 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
6215 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
6216 if(!isWasmInitialized) {
6217 throw new Error("initializeWasm() must be awaited first!");
6219 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
6220 return nativeResponseValue;
6222 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
6224 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
6225 if(!isWasmInitialized) {
6226 throw new Error("initializeWasm() must be awaited first!");
6228 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
6229 return nativeResponseValue;
6231 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
6233 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
6234 if(!isWasmInitialized) {
6235 throw new Error("initializeWasm() must be awaited first!");
6237 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
6238 return nativeResponseValue;
6240 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
6242 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
6247 // debug statements here
6249 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
6251 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
6252 if(!isWasmInitialized) {
6253 throw new Error("initializeWasm() must be awaited first!");
6255 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
6256 return nativeResponseValue;
6258 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
6260 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
6265 return nativeResponseValue;
6267 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
6269 export function COption_TypeZ_some(o: number): number {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
6274 return nativeResponseValue;
6276 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
6278 export function COption_TypeZ_none(): number {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
6283 return nativeResponseValue;
6285 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
6287 export function COption_TypeZ_free(_res: number): void {
6288 if(!isWasmInitialized) {
6289 throw new Error("initializeWasm() must be awaited first!");
6291 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
6292 // debug statements here
6294 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
6296 export function COption_TypeZ_clone_ptr(arg: number): number {
6297 if(!isWasmInitialized) {
6298 throw new Error("initializeWasm() must be awaited first!");
6300 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
6301 return nativeResponseValue;
6303 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
6305 export function COption_TypeZ_clone(orig: number): number {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
6310 return nativeResponseValue;
6312 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
6314 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
6319 return nativeResponseValue;
6321 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
6323 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
6328 return nativeResponseValue;
6330 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
6332 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
6337 return nativeResponseValue;
6339 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
6341 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
6342 if(!isWasmInitialized) {
6343 throw new Error("initializeWasm() must be awaited first!");
6345 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
6346 // debug statements here
6348 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
6350 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
6351 if(!isWasmInitialized) {
6352 throw new Error("initializeWasm() must be awaited first!");
6354 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
6355 return nativeResponseValue;
6357 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
6359 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
6360 if(!isWasmInitialized) {
6361 throw new Error("initializeWasm() must be awaited first!");
6363 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
6364 return nativeResponseValue;
6366 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
6368 export function CResult_StringErrorZ_ok(o: number): number {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
6373 return nativeResponseValue;
6375 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
6377 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
6378 if(!isWasmInitialized) {
6379 throw new Error("initializeWasm() must be awaited first!");
6381 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
6382 return nativeResponseValue;
6384 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
6386 export function CResult_StringErrorZ_is_ok(o: number): boolean {
6387 if(!isWasmInitialized) {
6388 throw new Error("initializeWasm() must be awaited first!");
6390 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
6391 return nativeResponseValue;
6393 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
6395 export function CResult_StringErrorZ_free(_res: number): void {
6396 if(!isWasmInitialized) {
6397 throw new Error("initializeWasm() must be awaited first!");
6399 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
6400 // debug statements here
6402 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
6404 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
6405 if(!isWasmInitialized) {
6406 throw new Error("initializeWasm() must be awaited first!");
6408 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
6409 return nativeResponseValue;
6411 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
6413 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
6418 return nativeResponseValue;
6420 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
6422 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
6423 if(!isWasmInitialized) {
6424 throw new Error("initializeWasm() must be awaited first!");
6426 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
6427 return nativeResponseValue;
6429 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
6431 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
6432 if(!isWasmInitialized) {
6433 throw new Error("initializeWasm() must be awaited first!");
6435 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
6436 // debug statements here
6438 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
6440 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
6441 if(!isWasmInitialized) {
6442 throw new Error("initializeWasm() must be awaited first!");
6444 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
6445 return nativeResponseValue;
6447 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
6449 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
6450 if(!isWasmInitialized) {
6451 throw new Error("initializeWasm() must be awaited first!");
6453 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
6454 return nativeResponseValue;
6456 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
6458 export function COption_MonitorEventZ_some(o: number): number {
6459 if(!isWasmInitialized) {
6460 throw new Error("initializeWasm() must be awaited first!");
6462 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
6463 return nativeResponseValue;
6465 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
6467 export function COption_MonitorEventZ_none(): number {
6468 if(!isWasmInitialized) {
6469 throw new Error("initializeWasm() must be awaited first!");
6471 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
6472 return nativeResponseValue;
6474 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
6476 export function COption_MonitorEventZ_free(_res: number): void {
6477 if(!isWasmInitialized) {
6478 throw new Error("initializeWasm() must be awaited first!");
6480 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
6481 // debug statements here
6483 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
6485 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
6486 if(!isWasmInitialized) {
6487 throw new Error("initializeWasm() must be awaited first!");
6489 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
6490 return nativeResponseValue;
6492 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
6494 export function COption_MonitorEventZ_clone(orig: number): number {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
6499 return nativeResponseValue;
6501 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
6503 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
6504 if(!isWasmInitialized) {
6505 throw new Error("initializeWasm() must be awaited first!");
6507 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
6508 return nativeResponseValue;
6510 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
6512 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
6517 return nativeResponseValue;
6519 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
6521 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
6526 return nativeResponseValue;
6528 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
6530 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
6535 // debug statements here
6537 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
6539 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
6544 return nativeResponseValue;
6546 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
6548 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
6553 return nativeResponseValue;
6555 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
6557 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
6562 return nativeResponseValue;
6564 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
6566 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
6571 return nativeResponseValue;
6573 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
6575 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
6580 return nativeResponseValue;
6582 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
6584 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
6589 // debug statements here
6591 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
6593 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
6598 return nativeResponseValue;
6600 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
6602 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
6603 if(!isWasmInitialized) {
6604 throw new Error("initializeWasm() must be awaited first!");
6606 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
6607 return nativeResponseValue;
6609 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6611 export function CResult_NoneNoneZ_ok(): number {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6616 return nativeResponseValue;
6618 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6620 export function CResult_NoneNoneZ_err(): number {
6621 if(!isWasmInitialized) {
6622 throw new Error("initializeWasm() must be awaited first!");
6624 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6625 return nativeResponseValue;
6627 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6629 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6630 if(!isWasmInitialized) {
6631 throw new Error("initializeWasm() must be awaited first!");
6633 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6634 return nativeResponseValue;
6636 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6638 export function CResult_NoneNoneZ_free(_res: number): void {
6639 if(!isWasmInitialized) {
6640 throw new Error("initializeWasm() must be awaited first!");
6642 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6643 // debug statements here
6645 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6647 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6648 if(!isWasmInitialized) {
6649 throw new Error("initializeWasm() must be awaited first!");
6651 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6652 return nativeResponseValue;
6654 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6656 export function CResult_NoneNoneZ_clone(orig: number): number {
6657 if(!isWasmInitialized) {
6658 throw new Error("initializeWasm() must be awaited first!");
6660 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6661 return nativeResponseValue;
6663 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
6665 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
6666 if(!isWasmInitialized) {
6667 throw new Error("initializeWasm() must be awaited first!");
6669 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
6670 return nativeResponseValue;
6672 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
6674 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
6675 if(!isWasmInitialized) {
6676 throw new Error("initializeWasm() must be awaited first!");
6678 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
6679 // debug statements here
6681 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
6683 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
6684 if(!isWasmInitialized) {
6685 throw new Error("initializeWasm() must be awaited first!");
6687 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
6688 return nativeResponseValue;
6690 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
6692 export function C2Tuple_u32ScriptZ_free(_res: number): void {
6693 if(!isWasmInitialized) {
6694 throw new Error("initializeWasm() must be awaited first!");
6696 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
6697 // debug statements here
6699 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
6701 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
6702 if(!isWasmInitialized) {
6703 throw new Error("initializeWasm() must be awaited first!");
6705 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
6706 // debug statements here
6708 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
6710 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
6711 if(!isWasmInitialized) {
6712 throw new Error("initializeWasm() must be awaited first!");
6714 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
6715 return nativeResponseValue;
6717 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
6719 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
6720 if(!isWasmInitialized) {
6721 throw new Error("initializeWasm() must be awaited first!");
6723 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
6724 // debug statements here
6726 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
6728 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
6729 if(!isWasmInitialized) {
6730 throw new Error("initializeWasm() must be awaited first!");
6732 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
6733 // debug statements here
6735 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
6737 export function CVec_MonitorEventZ_free(_res: number): void {
6738 if(!isWasmInitialized) {
6739 throw new Error("initializeWasm() must be awaited first!");
6741 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
6742 // debug statements here
6744 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
6746 export function CVec_EventZ_free(_res: number): void {
6747 if(!isWasmInitialized) {
6748 throw new Error("initializeWasm() must be awaited first!");
6750 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
6751 // debug statements here
6753 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
6755 export function CVec_TransactionZ_free(_res: number): void {
6756 if(!isWasmInitialized) {
6757 throw new Error("initializeWasm() must be awaited first!");
6759 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
6760 // debug statements here
6762 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
6764 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
6765 if(!isWasmInitialized) {
6766 throw new Error("initializeWasm() must be awaited first!");
6768 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
6769 return nativeResponseValue;
6771 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
6773 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
6774 if(!isWasmInitialized) {
6775 throw new Error("initializeWasm() must be awaited first!");
6777 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
6778 return nativeResponseValue;
6780 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
6782 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
6783 if(!isWasmInitialized) {
6784 throw new Error("initializeWasm() must be awaited first!");
6786 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
6787 return nativeResponseValue;
6789 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
6791 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
6792 if(!isWasmInitialized) {
6793 throw new Error("initializeWasm() must be awaited first!");
6795 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
6796 // debug statements here
6798 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
6800 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
6801 if(!isWasmInitialized) {
6802 throw new Error("initializeWasm() must be awaited first!");
6804 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
6805 // debug statements here
6807 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
6809 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
6810 if(!isWasmInitialized) {
6811 throw new Error("initializeWasm() must be awaited first!");
6813 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
6814 return nativeResponseValue;
6816 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
6818 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
6819 if(!isWasmInitialized) {
6820 throw new Error("initializeWasm() must be awaited first!");
6822 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
6823 return nativeResponseValue;
6825 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
6827 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
6828 if(!isWasmInitialized) {
6829 throw new Error("initializeWasm() must be awaited first!");
6831 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
6832 return nativeResponseValue;
6834 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
6836 export function C2Tuple_u32TxOutZ_free(_res: number): void {
6837 if(!isWasmInitialized) {
6838 throw new Error("initializeWasm() must be awaited first!");
6840 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
6841 // debug statements here
6843 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
6845 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
6846 if(!isWasmInitialized) {
6847 throw new Error("initializeWasm() must be awaited first!");
6849 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
6850 // debug statements here
6852 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
6854 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
6855 if(!isWasmInitialized) {
6856 throw new Error("initializeWasm() must be awaited first!");
6858 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
6859 return nativeResponseValue;
6861 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
6863 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
6864 if(!isWasmInitialized) {
6865 throw new Error("initializeWasm() must be awaited first!");
6867 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
6868 return nativeResponseValue;
6870 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
6872 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
6873 if(!isWasmInitialized) {
6874 throw new Error("initializeWasm() must be awaited first!");
6876 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
6877 return nativeResponseValue;
6879 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
6881 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
6882 if(!isWasmInitialized) {
6883 throw new Error("initializeWasm() must be awaited first!");
6885 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
6886 // debug statements here
6888 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
6890 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
6891 if(!isWasmInitialized) {
6892 throw new Error("initializeWasm() must be awaited first!");
6894 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
6895 // debug statements here
6897 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
6899 export function CVec_TxidZ_free(_res: number): void {
6900 if(!isWasmInitialized) {
6901 throw new Error("initializeWasm() must be awaited first!");
6903 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
6904 // debug statements here
6906 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
6908 export function CVec_BalanceZ_free(_res: number): void {
6909 if(!isWasmInitialized) {
6910 throw new Error("initializeWasm() must be awaited first!");
6912 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
6913 // debug statements here
6915 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
6917 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
6918 if(!isWasmInitialized) {
6919 throw new Error("initializeWasm() must be awaited first!");
6921 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
6922 return nativeResponseValue;
6924 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
6926 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
6927 if(!isWasmInitialized) {
6928 throw new Error("initializeWasm() must be awaited first!");
6930 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
6931 return nativeResponseValue;
6933 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
6935 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
6936 if(!isWasmInitialized) {
6937 throw new Error("initializeWasm() must be awaited first!");
6939 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
6940 return nativeResponseValue;
6942 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
6944 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
6945 if(!isWasmInitialized) {
6946 throw new Error("initializeWasm() must be awaited first!");
6948 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
6949 // debug statements here
6951 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
6953 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
6954 if(!isWasmInitialized) {
6955 throw new Error("initializeWasm() must be awaited first!");
6957 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
6958 return nativeResponseValue;
6960 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
6962 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
6963 if(!isWasmInitialized) {
6964 throw new Error("initializeWasm() must be awaited first!");
6966 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
6967 return nativeResponseValue;
6969 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
6971 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
6972 if(!isWasmInitialized) {
6973 throw new Error("initializeWasm() must be awaited first!");
6975 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
6976 return nativeResponseValue;
6978 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
6980 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
6981 if(!isWasmInitialized) {
6982 throw new Error("initializeWasm() must be awaited first!");
6984 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
6985 // debug statements here
6987 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
6989 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
6990 if(!isWasmInitialized) {
6991 throw new Error("initializeWasm() must be awaited first!");
6993 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
6994 return nativeResponseValue;
6996 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
6998 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
6999 if(!isWasmInitialized) {
7000 throw new Error("initializeWasm() must be awaited first!");
7002 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
7003 return nativeResponseValue;
7005 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7007 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7008 if(!isWasmInitialized) {
7009 throw new Error("initializeWasm() must be awaited first!");
7011 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7012 return nativeResponseValue;
7014 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7016 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7017 if(!isWasmInitialized) {
7018 throw new Error("initializeWasm() must be awaited first!");
7020 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7021 return nativeResponseValue;
7023 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7025 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7026 if(!isWasmInitialized) {
7027 throw new Error("initializeWasm() must be awaited first!");
7029 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7030 return nativeResponseValue;
7032 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7034 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7035 if(!isWasmInitialized) {
7036 throw new Error("initializeWasm() must be awaited first!");
7038 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7039 // debug statements here
7041 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7043 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7044 if(!isWasmInitialized) {
7045 throw new Error("initializeWasm() must be awaited first!");
7047 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7048 return nativeResponseValue;
7050 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7052 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7053 if(!isWasmInitialized) {
7054 throw new Error("initializeWasm() must be awaited first!");
7056 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7057 return nativeResponseValue;
7059 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7061 export function CVec_RouteHopZ_free(_res: number): void {
7062 if(!isWasmInitialized) {
7063 throw new Error("initializeWasm() must be awaited first!");
7065 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7066 // debug statements here
7068 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7070 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7071 if(!isWasmInitialized) {
7072 throw new Error("initializeWasm() must be awaited first!");
7074 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7075 // debug statements here
7077 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7079 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7080 if(!isWasmInitialized) {
7081 throw new Error("initializeWasm() must be awaited first!");
7083 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7084 return nativeResponseValue;
7086 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7088 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7089 if(!isWasmInitialized) {
7090 throw new Error("initializeWasm() must be awaited first!");
7092 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7093 return nativeResponseValue;
7095 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7097 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7098 if(!isWasmInitialized) {
7099 throw new Error("initializeWasm() must be awaited first!");
7101 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7102 return nativeResponseValue;
7104 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7106 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7107 if(!isWasmInitialized) {
7108 throw new Error("initializeWasm() must be awaited first!");
7110 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7111 // debug statements here
7113 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7115 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7116 if(!isWasmInitialized) {
7117 throw new Error("initializeWasm() must be awaited first!");
7119 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7120 return nativeResponseValue;
7122 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7124 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7125 if(!isWasmInitialized) {
7126 throw new Error("initializeWasm() must be awaited first!");
7128 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7129 return nativeResponseValue;
7131 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7133 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7134 if(!isWasmInitialized) {
7135 throw new Error("initializeWasm() must be awaited first!");
7137 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7138 return nativeResponseValue;
7140 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7142 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7143 if(!isWasmInitialized) {
7144 throw new Error("initializeWasm() must be awaited first!");
7146 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7147 return nativeResponseValue;
7149 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7151 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7152 if(!isWasmInitialized) {
7153 throw new Error("initializeWasm() must be awaited first!");
7155 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7156 return nativeResponseValue;
7158 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7160 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7161 if(!isWasmInitialized) {
7162 throw new Error("initializeWasm() must be awaited first!");
7164 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7165 // debug statements here
7167 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7169 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7170 if(!isWasmInitialized) {
7171 throw new Error("initializeWasm() must be awaited first!");
7173 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7174 return nativeResponseValue;
7176 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7178 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7179 if(!isWasmInitialized) {
7180 throw new Error("initializeWasm() must be awaited first!");
7182 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7183 return nativeResponseValue;
7185 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7187 export function CVec_RouteHintZ_free(_res: number): void {
7188 if(!isWasmInitialized) {
7189 throw new Error("initializeWasm() must be awaited first!");
7191 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7192 // debug statements here
7194 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7196 export function COption_u64Z_some(o: bigint): number {
7197 if(!isWasmInitialized) {
7198 throw new Error("initializeWasm() must be awaited first!");
7200 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7201 return nativeResponseValue;
7203 // struct LDKCOption_u64Z COption_u64Z_none(void);
7205 export function COption_u64Z_none(): number {
7206 if(!isWasmInitialized) {
7207 throw new Error("initializeWasm() must be awaited first!");
7209 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7210 return nativeResponseValue;
7212 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7214 export function COption_u64Z_free(_res: number): void {
7215 if(!isWasmInitialized) {
7216 throw new Error("initializeWasm() must be awaited first!");
7218 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7219 // debug statements here
7221 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7223 export function COption_u64Z_clone_ptr(arg: number): number {
7224 if(!isWasmInitialized) {
7225 throw new Error("initializeWasm() must be awaited first!");
7227 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7228 return nativeResponseValue;
7230 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7232 export function COption_u64Z_clone(orig: number): number {
7233 if(!isWasmInitialized) {
7234 throw new Error("initializeWasm() must be awaited first!");
7236 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7237 return nativeResponseValue;
7239 // struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_ok(struct LDKPayee o);
7241 export function CResult_PayeeDecodeErrorZ_ok(o: number): number {
7242 if(!isWasmInitialized) {
7243 throw new Error("initializeWasm() must be awaited first!");
7245 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_ok(o);
7246 return nativeResponseValue;
7248 // struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_err(struct LDKDecodeError e);
7250 export function CResult_PayeeDecodeErrorZ_err(e: number): number {
7251 if(!isWasmInitialized) {
7252 throw new Error("initializeWasm() must be awaited first!");
7254 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_err(e);
7255 return nativeResponseValue;
7257 // bool CResult_PayeeDecodeErrorZ_is_ok(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR o);
7259 export function CResult_PayeeDecodeErrorZ_is_ok(o: number): boolean {
7260 if(!isWasmInitialized) {
7261 throw new Error("initializeWasm() must be awaited first!");
7263 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_is_ok(o);
7264 return nativeResponseValue;
7266 // void CResult_PayeeDecodeErrorZ_free(struct LDKCResult_PayeeDecodeErrorZ _res);
7268 export function CResult_PayeeDecodeErrorZ_free(_res: number): void {
7269 if(!isWasmInitialized) {
7270 throw new Error("initializeWasm() must be awaited first!");
7272 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_free(_res);
7273 // debug statements here
7275 // uintptr_t CResult_PayeeDecodeErrorZ_clone_ptr(LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR arg);
7277 export function CResult_PayeeDecodeErrorZ_clone_ptr(arg: number): number {
7278 if(!isWasmInitialized) {
7279 throw new Error("initializeWasm() must be awaited first!");
7281 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_clone_ptr(arg);
7282 return nativeResponseValue;
7284 // struct LDKCResult_PayeeDecodeErrorZ CResult_PayeeDecodeErrorZ_clone(const struct LDKCResult_PayeeDecodeErrorZ *NONNULL_PTR orig);
7286 export function CResult_PayeeDecodeErrorZ_clone(orig: number): number {
7287 if(!isWasmInitialized) {
7288 throw new Error("initializeWasm() must be awaited first!");
7290 const nativeResponseValue = wasm.TS_CResult_PayeeDecodeErrorZ_clone(orig);
7291 return nativeResponseValue;
7293 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7295 export function CVec_RouteHintHopZ_free(_res: number): void {
7296 if(!isWasmInitialized) {
7297 throw new Error("initializeWasm() must be awaited first!");
7299 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7300 // debug statements here
7302 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7304 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7305 if(!isWasmInitialized) {
7306 throw new Error("initializeWasm() must be awaited first!");
7308 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7309 return nativeResponseValue;
7311 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7313 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7314 if(!isWasmInitialized) {
7315 throw new Error("initializeWasm() must be awaited first!");
7317 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7318 return nativeResponseValue;
7320 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7322 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7323 if(!isWasmInitialized) {
7324 throw new Error("initializeWasm() must be awaited first!");
7326 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7327 return nativeResponseValue;
7329 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7331 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7332 if(!isWasmInitialized) {
7333 throw new Error("initializeWasm() must be awaited first!");
7335 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7336 // debug statements here
7338 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7340 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7341 if(!isWasmInitialized) {
7342 throw new Error("initializeWasm() must be awaited first!");
7344 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7345 return nativeResponseValue;
7347 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7349 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7350 if(!isWasmInitialized) {
7351 throw new Error("initializeWasm() must be awaited first!");
7353 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7354 return nativeResponseValue;
7356 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7358 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7359 if(!isWasmInitialized) {
7360 throw new Error("initializeWasm() must be awaited first!");
7362 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7363 return nativeResponseValue;
7365 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7367 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7368 if(!isWasmInitialized) {
7369 throw new Error("initializeWasm() must be awaited first!");
7371 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7372 return nativeResponseValue;
7374 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7376 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7377 if(!isWasmInitialized) {
7378 throw new Error("initializeWasm() must be awaited first!");
7380 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7381 return nativeResponseValue;
7383 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7385 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7390 // debug statements here
7392 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7394 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7395 if(!isWasmInitialized) {
7396 throw new Error("initializeWasm() must be awaited first!");
7398 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7399 return nativeResponseValue;
7401 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7403 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7404 if(!isWasmInitialized) {
7405 throw new Error("initializeWasm() must be awaited first!");
7407 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7408 return nativeResponseValue;
7410 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7412 export function CVec_ChannelDetailsZ_free(_res: number): void {
7413 if(!isWasmInitialized) {
7414 throw new Error("initializeWasm() must be awaited first!");
7416 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7417 // debug statements here
7419 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7421 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7426 return nativeResponseValue;
7428 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7430 export function CResult_RouteLightningErrorZ_err(e: number): number {
7431 if(!isWasmInitialized) {
7432 throw new Error("initializeWasm() must be awaited first!");
7434 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7435 return nativeResponseValue;
7437 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7439 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7440 if(!isWasmInitialized) {
7441 throw new Error("initializeWasm() must be awaited first!");
7443 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7444 return nativeResponseValue;
7446 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7448 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7449 if(!isWasmInitialized) {
7450 throw new Error("initializeWasm() must be awaited first!");
7452 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7453 // debug statements here
7455 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7457 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7458 if(!isWasmInitialized) {
7459 throw new Error("initializeWasm() must be awaited first!");
7461 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
7462 return nativeResponseValue;
7464 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
7466 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
7467 if(!isWasmInitialized) {
7468 throw new Error("initializeWasm() must be awaited first!");
7470 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
7471 return nativeResponseValue;
7473 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
7475 export function CResult_NoneLightningErrorZ_ok(): number {
7476 if(!isWasmInitialized) {
7477 throw new Error("initializeWasm() must be awaited first!");
7479 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
7480 return nativeResponseValue;
7482 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
7484 export function CResult_NoneLightningErrorZ_err(e: number): number {
7485 if(!isWasmInitialized) {
7486 throw new Error("initializeWasm() must be awaited first!");
7488 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
7489 return nativeResponseValue;
7491 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
7493 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
7494 if(!isWasmInitialized) {
7495 throw new Error("initializeWasm() must be awaited first!");
7497 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
7498 return nativeResponseValue;
7500 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
7502 export function CResult_NoneLightningErrorZ_free(_res: number): void {
7503 if(!isWasmInitialized) {
7504 throw new Error("initializeWasm() must be awaited first!");
7506 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
7507 // debug statements here
7509 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
7511 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
7512 if(!isWasmInitialized) {
7513 throw new Error("initializeWasm() must be awaited first!");
7515 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
7516 return nativeResponseValue;
7518 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
7520 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
7521 if(!isWasmInitialized) {
7522 throw new Error("initializeWasm() must be awaited first!");
7524 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
7525 return nativeResponseValue;
7527 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
7529 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
7530 if(!isWasmInitialized) {
7531 throw new Error("initializeWasm() must be awaited first!");
7533 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
7534 return nativeResponseValue;
7536 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
7538 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
7539 if(!isWasmInitialized) {
7540 throw new Error("initializeWasm() must be awaited first!");
7542 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
7543 return nativeResponseValue;
7545 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
7547 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
7548 if(!isWasmInitialized) {
7549 throw new Error("initializeWasm() must be awaited first!");
7551 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
7552 return nativeResponseValue;
7554 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
7556 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
7557 if(!isWasmInitialized) {
7558 throw new Error("initializeWasm() must be awaited first!");
7560 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
7561 // debug statements here
7563 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
7565 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
7566 if(!isWasmInitialized) {
7567 throw new Error("initializeWasm() must be awaited first!");
7569 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
7570 // debug statements here
7572 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
7574 export function CVec_MessageSendEventZ_free(_res: number): void {
7575 if(!isWasmInitialized) {
7576 throw new Error("initializeWasm() must be awaited first!");
7578 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
7579 // debug statements here
7581 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
7583 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
7584 if(!isWasmInitialized) {
7585 throw new Error("initializeWasm() must be awaited first!");
7587 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
7588 return nativeResponseValue;
7590 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
7592 export function CResult_boolLightningErrorZ_err(e: number): number {
7593 if(!isWasmInitialized) {
7594 throw new Error("initializeWasm() must be awaited first!");
7596 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
7597 return nativeResponseValue;
7599 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
7601 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
7602 if(!isWasmInitialized) {
7603 throw new Error("initializeWasm() must be awaited first!");
7605 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
7606 return nativeResponseValue;
7608 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
7610 export function CResult_boolLightningErrorZ_free(_res: number): void {
7611 if(!isWasmInitialized) {
7612 throw new Error("initializeWasm() must be awaited first!");
7614 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
7615 // debug statements here
7617 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
7619 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
7620 if(!isWasmInitialized) {
7621 throw new Error("initializeWasm() must be awaited first!");
7623 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
7624 return nativeResponseValue;
7626 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
7628 export function CResult_boolLightningErrorZ_clone(orig: number): number {
7629 if(!isWasmInitialized) {
7630 throw new Error("initializeWasm() must be awaited first!");
7632 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
7633 return nativeResponseValue;
7635 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
7637 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
7638 if(!isWasmInitialized) {
7639 throw new Error("initializeWasm() must be awaited first!");
7641 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
7642 return nativeResponseValue;
7644 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
7646 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
7647 if(!isWasmInitialized) {
7648 throw new Error("initializeWasm() must be awaited first!");
7650 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
7651 return nativeResponseValue;
7653 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
7655 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
7656 if(!isWasmInitialized) {
7657 throw new Error("initializeWasm() must be awaited first!");
7659 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
7660 return nativeResponseValue;
7662 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
7664 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
7665 if(!isWasmInitialized) {
7666 throw new Error("initializeWasm() must be awaited first!");
7668 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
7669 // debug statements here
7671 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
7673 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
7674 if(!isWasmInitialized) {
7675 throw new Error("initializeWasm() must be awaited first!");
7677 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
7678 // debug statements here
7680 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
7682 export function CVec_NodeAnnouncementZ_free(_res: number): void {
7683 if(!isWasmInitialized) {
7684 throw new Error("initializeWasm() must be awaited first!");
7686 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
7687 // debug statements here
7689 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
7691 export function CVec_PublicKeyZ_free(_res: number): void {
7692 if(!isWasmInitialized) {
7693 throw new Error("initializeWasm() must be awaited first!");
7695 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
7696 // debug statements here
7698 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
7700 export function CVec_u8Z_free(_res: number): void {
7701 if(!isWasmInitialized) {
7702 throw new Error("initializeWasm() must be awaited first!");
7704 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
7705 // debug statements here
7707 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
7709 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
7710 if(!isWasmInitialized) {
7711 throw new Error("initializeWasm() must be awaited first!");
7713 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
7714 return nativeResponseValue;
7716 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
7718 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
7719 if(!isWasmInitialized) {
7720 throw new Error("initializeWasm() must be awaited first!");
7722 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
7723 return nativeResponseValue;
7725 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
7727 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
7728 if(!isWasmInitialized) {
7729 throw new Error("initializeWasm() must be awaited first!");
7731 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
7732 return nativeResponseValue;
7734 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
7736 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
7737 if(!isWasmInitialized) {
7738 throw new Error("initializeWasm() must be awaited first!");
7740 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
7741 // debug statements here
7743 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
7745 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
7746 if(!isWasmInitialized) {
7747 throw new Error("initializeWasm() must be awaited first!");
7749 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
7750 return nativeResponseValue;
7752 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
7754 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
7755 if(!isWasmInitialized) {
7756 throw new Error("initializeWasm() must be awaited first!");
7758 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
7759 return nativeResponseValue;
7761 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
7763 export function CResult_NonePeerHandleErrorZ_ok(): number {
7764 if(!isWasmInitialized) {
7765 throw new Error("initializeWasm() must be awaited first!");
7767 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
7768 return nativeResponseValue;
7770 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
7772 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
7773 if(!isWasmInitialized) {
7774 throw new Error("initializeWasm() must be awaited first!");
7776 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
7777 return nativeResponseValue;
7779 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
7781 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
7782 if(!isWasmInitialized) {
7783 throw new Error("initializeWasm() must be awaited first!");
7785 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
7786 return nativeResponseValue;
7788 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
7790 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
7791 if(!isWasmInitialized) {
7792 throw new Error("initializeWasm() must be awaited first!");
7794 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
7795 // debug statements here
7797 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
7799 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
7800 if(!isWasmInitialized) {
7801 throw new Error("initializeWasm() must be awaited first!");
7803 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
7804 return nativeResponseValue;
7806 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
7808 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
7809 if(!isWasmInitialized) {
7810 throw new Error("initializeWasm() must be awaited first!");
7812 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
7813 return nativeResponseValue;
7815 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
7817 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
7818 if(!isWasmInitialized) {
7819 throw new Error("initializeWasm() must be awaited first!");
7821 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
7822 return nativeResponseValue;
7824 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
7826 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
7827 if(!isWasmInitialized) {
7828 throw new Error("initializeWasm() must be awaited first!");
7830 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
7831 return nativeResponseValue;
7833 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
7835 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
7836 if(!isWasmInitialized) {
7837 throw new Error("initializeWasm() must be awaited first!");
7839 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
7840 return nativeResponseValue;
7842 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
7844 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
7845 if(!isWasmInitialized) {
7846 throw new Error("initializeWasm() must be awaited first!");
7848 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
7849 // debug statements here
7851 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
7853 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
7854 if(!isWasmInitialized) {
7855 throw new Error("initializeWasm() must be awaited first!");
7857 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
7858 return nativeResponseValue;
7860 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
7862 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
7863 if(!isWasmInitialized) {
7864 throw new Error("initializeWasm() must be awaited first!");
7866 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
7867 return nativeResponseValue;
7869 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
7871 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
7872 if(!isWasmInitialized) {
7873 throw new Error("initializeWasm() must be awaited first!");
7875 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
7876 return nativeResponseValue;
7878 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
7880 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
7881 if(!isWasmInitialized) {
7882 throw new Error("initializeWasm() must be awaited first!");
7884 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
7885 return nativeResponseValue;
7887 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
7889 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
7890 if(!isWasmInitialized) {
7891 throw new Error("initializeWasm() must be awaited first!");
7893 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
7894 return nativeResponseValue;
7896 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
7898 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
7899 if(!isWasmInitialized) {
7900 throw new Error("initializeWasm() must be awaited first!");
7902 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
7903 // debug statements here
7905 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
7907 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
7908 if(!isWasmInitialized) {
7909 throw new Error("initializeWasm() must be awaited first!");
7911 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
7912 return nativeResponseValue;
7914 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
7916 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
7917 if(!isWasmInitialized) {
7918 throw new Error("initializeWasm() must be awaited first!");
7920 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
7921 return nativeResponseValue;
7923 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
7925 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
7926 if(!isWasmInitialized) {
7927 throw new Error("initializeWasm() must be awaited first!");
7929 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
7930 return nativeResponseValue;
7932 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
7934 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
7935 if(!isWasmInitialized) {
7936 throw new Error("initializeWasm() must be awaited first!");
7938 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
7939 return nativeResponseValue;
7941 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
7943 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
7944 if(!isWasmInitialized) {
7945 throw new Error("initializeWasm() must be awaited first!");
7947 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
7948 return nativeResponseValue;
7950 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
7952 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
7953 if(!isWasmInitialized) {
7954 throw new Error("initializeWasm() must be awaited first!");
7956 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
7957 // debug statements here
7959 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
7961 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
7962 if(!isWasmInitialized) {
7963 throw new Error("initializeWasm() must be awaited first!");
7965 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
7966 return nativeResponseValue;
7968 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
7970 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
7971 if(!isWasmInitialized) {
7972 throw new Error("initializeWasm() must be awaited first!");
7974 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
7975 return nativeResponseValue;
7977 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
7979 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
7980 if(!isWasmInitialized) {
7981 throw new Error("initializeWasm() must be awaited first!");
7983 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
7984 return nativeResponseValue;
7986 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
7988 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
7989 if(!isWasmInitialized) {
7990 throw new Error("initializeWasm() must be awaited first!");
7992 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
7993 return nativeResponseValue;
7995 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
7997 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
7998 if(!isWasmInitialized) {
7999 throw new Error("initializeWasm() must be awaited first!");
8001 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8002 // debug statements here
8004 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8006 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8007 if(!isWasmInitialized) {
8008 throw new Error("initializeWasm() must be awaited first!");
8010 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8011 return nativeResponseValue;
8013 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8015 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8016 if(!isWasmInitialized) {
8017 throw new Error("initializeWasm() must be awaited first!");
8019 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8020 return nativeResponseValue;
8022 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8024 export function COption_ClosureReasonZ_some(o: number): number {
8025 if(!isWasmInitialized) {
8026 throw new Error("initializeWasm() must be awaited first!");
8028 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8029 return nativeResponseValue;
8031 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8033 export function COption_ClosureReasonZ_none(): number {
8034 if(!isWasmInitialized) {
8035 throw new Error("initializeWasm() must be awaited first!");
8037 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8038 return nativeResponseValue;
8040 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8042 export function COption_ClosureReasonZ_free(_res: number): void {
8043 if(!isWasmInitialized) {
8044 throw new Error("initializeWasm() must be awaited first!");
8046 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8047 // debug statements here
8049 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8051 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8052 if(!isWasmInitialized) {
8053 throw new Error("initializeWasm() must be awaited first!");
8055 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8056 return nativeResponseValue;
8058 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8060 export function COption_ClosureReasonZ_clone(orig: number): number {
8061 if(!isWasmInitialized) {
8062 throw new Error("initializeWasm() must be awaited first!");
8064 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8065 return nativeResponseValue;
8067 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8069 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8070 if(!isWasmInitialized) {
8071 throw new Error("initializeWasm() must be awaited first!");
8073 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8074 return nativeResponseValue;
8076 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8078 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8079 if(!isWasmInitialized) {
8080 throw new Error("initializeWasm() must be awaited first!");
8082 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8083 return nativeResponseValue;
8085 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8087 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8088 if(!isWasmInitialized) {
8089 throw new Error("initializeWasm() must be awaited first!");
8091 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8092 return nativeResponseValue;
8094 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8096 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8097 if(!isWasmInitialized) {
8098 throw new Error("initializeWasm() must be awaited first!");
8100 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8101 // debug statements here
8103 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8105 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8106 if(!isWasmInitialized) {
8107 throw new Error("initializeWasm() must be awaited first!");
8109 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8110 return nativeResponseValue;
8112 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8114 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8115 if(!isWasmInitialized) {
8116 throw new Error("initializeWasm() must be awaited first!");
8118 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8119 return nativeResponseValue;
8121 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8123 export function COption_NetworkUpdateZ_some(o: number): number {
8124 if(!isWasmInitialized) {
8125 throw new Error("initializeWasm() must be awaited first!");
8127 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8128 return nativeResponseValue;
8130 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8132 export function COption_NetworkUpdateZ_none(): number {
8133 if(!isWasmInitialized) {
8134 throw new Error("initializeWasm() must be awaited first!");
8136 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8137 return nativeResponseValue;
8139 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8141 export function COption_NetworkUpdateZ_free(_res: number): void {
8142 if(!isWasmInitialized) {
8143 throw new Error("initializeWasm() must be awaited first!");
8145 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8146 // debug statements here
8148 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8150 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8151 if(!isWasmInitialized) {
8152 throw new Error("initializeWasm() must be awaited first!");
8154 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8155 return nativeResponseValue;
8157 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8159 export function COption_NetworkUpdateZ_clone(orig: number): number {
8160 if(!isWasmInitialized) {
8161 throw new Error("initializeWasm() must be awaited first!");
8163 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8164 return nativeResponseValue;
8166 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8168 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8169 if(!isWasmInitialized) {
8170 throw new Error("initializeWasm() must be awaited first!");
8172 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8173 // debug statements here
8175 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8177 export function COption_EventZ_some(o: number): number {
8178 if(!isWasmInitialized) {
8179 throw new Error("initializeWasm() must be awaited first!");
8181 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8182 return nativeResponseValue;
8184 // struct LDKCOption_EventZ COption_EventZ_none(void);
8186 export function COption_EventZ_none(): number {
8187 if(!isWasmInitialized) {
8188 throw new Error("initializeWasm() must be awaited first!");
8190 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8191 return nativeResponseValue;
8193 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8195 export function COption_EventZ_free(_res: number): void {
8196 if(!isWasmInitialized) {
8197 throw new Error("initializeWasm() must be awaited first!");
8199 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8200 // debug statements here
8202 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8204 export function COption_EventZ_clone_ptr(arg: number): number {
8205 if(!isWasmInitialized) {
8206 throw new Error("initializeWasm() must be awaited first!");
8208 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8209 return nativeResponseValue;
8211 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8213 export function COption_EventZ_clone(orig: number): number {
8214 if(!isWasmInitialized) {
8215 throw new Error("initializeWasm() must be awaited first!");
8217 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8218 return nativeResponseValue;
8220 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8222 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8223 if(!isWasmInitialized) {
8224 throw new Error("initializeWasm() must be awaited first!");
8226 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8227 return nativeResponseValue;
8229 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8231 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8232 if(!isWasmInitialized) {
8233 throw new Error("initializeWasm() must be awaited first!");
8235 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8236 return nativeResponseValue;
8238 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8240 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8241 if(!isWasmInitialized) {
8242 throw new Error("initializeWasm() must be awaited first!");
8244 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8245 return nativeResponseValue;
8247 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8249 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8250 if(!isWasmInitialized) {
8251 throw new Error("initializeWasm() must be awaited first!");
8253 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8254 // debug statements here
8256 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8258 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8259 if(!isWasmInitialized) {
8260 throw new Error("initializeWasm() must be awaited first!");
8262 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8263 return nativeResponseValue;
8265 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8267 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8268 if(!isWasmInitialized) {
8269 throw new Error("initializeWasm() must be awaited first!");
8271 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8272 return nativeResponseValue;
8274 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
8276 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
8277 if(!isWasmInitialized) {
8278 throw new Error("initializeWasm() must be awaited first!");
8280 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
8281 return nativeResponseValue;
8283 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
8285 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
8286 if(!isWasmInitialized) {
8287 throw new Error("initializeWasm() must be awaited first!");
8289 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
8290 return nativeResponseValue;
8292 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
8294 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
8295 if(!isWasmInitialized) {
8296 throw new Error("initializeWasm() must be awaited first!");
8298 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
8299 return nativeResponseValue;
8301 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
8303 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
8304 if(!isWasmInitialized) {
8305 throw new Error("initializeWasm() must be awaited first!");
8307 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
8308 // debug statements here
8310 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
8312 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
8313 if(!isWasmInitialized) {
8314 throw new Error("initializeWasm() must be awaited first!");
8316 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
8317 return nativeResponseValue;
8319 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
8321 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
8322 if(!isWasmInitialized) {
8323 throw new Error("initializeWasm() must be awaited first!");
8325 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
8326 return nativeResponseValue;
8328 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
8330 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
8331 if(!isWasmInitialized) {
8332 throw new Error("initializeWasm() must be awaited first!");
8334 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
8335 return nativeResponseValue;
8337 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
8339 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
8340 if(!isWasmInitialized) {
8341 throw new Error("initializeWasm() must be awaited first!");
8343 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
8344 return nativeResponseValue;
8346 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
8348 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
8349 if(!isWasmInitialized) {
8350 throw new Error("initializeWasm() must be awaited first!");
8352 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
8353 return nativeResponseValue;
8355 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
8357 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
8358 if(!isWasmInitialized) {
8359 throw new Error("initializeWasm() must be awaited first!");
8361 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
8362 // debug statements here
8364 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
8366 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
8367 if(!isWasmInitialized) {
8368 throw new Error("initializeWasm() must be awaited first!");
8370 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
8371 return nativeResponseValue;
8373 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
8375 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
8376 if(!isWasmInitialized) {
8377 throw new Error("initializeWasm() must be awaited first!");
8379 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
8380 return nativeResponseValue;
8382 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
8384 export function COption_AccessZ_some(o: number): number {
8385 if(!isWasmInitialized) {
8386 throw new Error("initializeWasm() must be awaited first!");
8388 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
8389 return nativeResponseValue;
8391 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
8393 export function COption_AccessZ_none(): number {
8394 if(!isWasmInitialized) {
8395 throw new Error("initializeWasm() must be awaited first!");
8397 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
8398 return nativeResponseValue;
8400 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
8402 export function COption_AccessZ_free(_res: number): void {
8403 if(!isWasmInitialized) {
8404 throw new Error("initializeWasm() must be awaited first!");
8406 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
8407 // debug statements here
8409 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
8411 export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
8412 if(!isWasmInitialized) {
8413 throw new Error("initializeWasm() must be awaited first!");
8415 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_ok(o);
8416 return nativeResponseValue;
8418 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
8420 export function CResult_DirectionalChannelInfoDecodeErrorZ_err(e: number): number {
8421 if(!isWasmInitialized) {
8422 throw new Error("initializeWasm() must be awaited first!");
8424 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_err(e);
8425 return nativeResponseValue;
8427 // bool CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR o);
8429 export function CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
8430 if(!isWasmInitialized) {
8431 throw new Error("initializeWasm() must be awaited first!");
8433 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_is_ok(o);
8434 return nativeResponseValue;
8436 // void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
8438 export function CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: number): void {
8439 if(!isWasmInitialized) {
8440 throw new Error("initializeWasm() must be awaited first!");
8442 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_free(_res);
8443 // debug statements here
8445 // uintptr_t CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR arg);
8447 export function CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
8448 if(!isWasmInitialized) {
8449 throw new Error("initializeWasm() must be awaited first!");
8451 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone_ptr(arg);
8452 return nativeResponseValue;
8454 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
8456 export function CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: number): number {
8457 if(!isWasmInitialized) {
8458 throw new Error("initializeWasm() must be awaited first!");
8460 const nativeResponseValue = wasm.TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig);
8461 return nativeResponseValue;
8463 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
8465 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
8466 if(!isWasmInitialized) {
8467 throw new Error("initializeWasm() must be awaited first!");
8469 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
8470 return nativeResponseValue;
8472 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
8474 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
8475 if(!isWasmInitialized) {
8476 throw new Error("initializeWasm() must be awaited first!");
8478 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
8479 return nativeResponseValue;
8481 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
8483 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
8484 if(!isWasmInitialized) {
8485 throw new Error("initializeWasm() must be awaited first!");
8487 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
8488 return nativeResponseValue;
8490 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
8492 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
8493 if(!isWasmInitialized) {
8494 throw new Error("initializeWasm() must be awaited first!");
8496 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
8497 // debug statements here
8499 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
8501 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
8502 if(!isWasmInitialized) {
8503 throw new Error("initializeWasm() must be awaited first!");
8505 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
8506 return nativeResponseValue;
8508 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
8510 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
8511 if(!isWasmInitialized) {
8512 throw new Error("initializeWasm() must be awaited first!");
8514 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
8515 return nativeResponseValue;
8517 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
8519 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
8520 if(!isWasmInitialized) {
8521 throw new Error("initializeWasm() must be awaited first!");
8523 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
8524 return nativeResponseValue;
8526 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
8528 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
8529 if(!isWasmInitialized) {
8530 throw new Error("initializeWasm() must be awaited first!");
8532 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
8533 return nativeResponseValue;
8535 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
8537 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
8538 if(!isWasmInitialized) {
8539 throw new Error("initializeWasm() must be awaited first!");
8541 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
8542 return nativeResponseValue;
8544 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
8546 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
8547 if(!isWasmInitialized) {
8548 throw new Error("initializeWasm() must be awaited first!");
8550 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
8551 // debug statements here
8553 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
8555 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
8556 if(!isWasmInitialized) {
8557 throw new Error("initializeWasm() must be awaited first!");
8559 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
8560 return nativeResponseValue;
8562 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
8564 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
8565 if(!isWasmInitialized) {
8566 throw new Error("initializeWasm() must be awaited first!");
8568 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
8569 return nativeResponseValue;
8571 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
8573 export function CVec_NetAddressZ_free(_res: number): void {
8574 if(!isWasmInitialized) {
8575 throw new Error("initializeWasm() must be awaited first!");
8577 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
8578 // debug statements here
8580 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
8582 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
8583 if(!isWasmInitialized) {
8584 throw new Error("initializeWasm() must be awaited first!");
8586 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
8587 return nativeResponseValue;
8589 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
8591 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
8592 if(!isWasmInitialized) {
8593 throw new Error("initializeWasm() must be awaited first!");
8595 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
8596 return nativeResponseValue;
8598 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
8600 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
8601 if(!isWasmInitialized) {
8602 throw new Error("initializeWasm() must be awaited first!");
8604 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
8605 return nativeResponseValue;
8607 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
8609 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
8610 if(!isWasmInitialized) {
8611 throw new Error("initializeWasm() must be awaited first!");
8613 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
8614 // debug statements here
8616 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
8618 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
8619 if(!isWasmInitialized) {
8620 throw new Error("initializeWasm() must be awaited first!");
8622 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
8623 return nativeResponseValue;
8625 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
8627 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
8628 if(!isWasmInitialized) {
8629 throw new Error("initializeWasm() must be awaited first!");
8631 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
8632 return nativeResponseValue;
8634 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8636 export function CVec_u64Z_free(_res: number): void {
8637 if(!isWasmInitialized) {
8638 throw new Error("initializeWasm() must be awaited first!");
8640 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8641 // debug statements here
8643 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
8645 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
8646 if(!isWasmInitialized) {
8647 throw new Error("initializeWasm() must be awaited first!");
8649 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
8650 return nativeResponseValue;
8652 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
8654 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
8655 if(!isWasmInitialized) {
8656 throw new Error("initializeWasm() must be awaited first!");
8658 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
8659 return nativeResponseValue;
8661 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
8663 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
8664 if(!isWasmInitialized) {
8665 throw new Error("initializeWasm() must be awaited first!");
8667 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
8668 return nativeResponseValue;
8670 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
8672 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
8673 if(!isWasmInitialized) {
8674 throw new Error("initializeWasm() must be awaited first!");
8676 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
8677 // debug statements here
8679 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
8681 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
8682 if(!isWasmInitialized) {
8683 throw new Error("initializeWasm() must be awaited first!");
8685 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
8686 return nativeResponseValue;
8688 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
8690 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
8691 if(!isWasmInitialized) {
8692 throw new Error("initializeWasm() must be awaited first!");
8694 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
8695 return nativeResponseValue;
8697 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
8699 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
8700 if(!isWasmInitialized) {
8701 throw new Error("initializeWasm() must be awaited first!");
8703 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
8704 return nativeResponseValue;
8706 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
8708 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
8709 if(!isWasmInitialized) {
8710 throw new Error("initializeWasm() must be awaited first!");
8712 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
8713 return nativeResponseValue;
8715 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
8717 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
8718 if(!isWasmInitialized) {
8719 throw new Error("initializeWasm() must be awaited first!");
8721 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
8722 return nativeResponseValue;
8724 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
8726 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
8727 if(!isWasmInitialized) {
8728 throw new Error("initializeWasm() must be awaited first!");
8730 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
8731 // debug statements here
8733 // uintptr_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
8735 export function CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg: number): number {
8736 if(!isWasmInitialized) {
8737 throw new Error("initializeWasm() must be awaited first!");
8739 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg);
8740 return nativeResponseValue;
8742 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
8744 export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
8745 if(!isWasmInitialized) {
8746 throw new Error("initializeWasm() must be awaited first!");
8748 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone(orig);
8749 return nativeResponseValue;
8751 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
8753 export function COption_CVec_NetAddressZZ_some(o: number): number {
8754 if(!isWasmInitialized) {
8755 throw new Error("initializeWasm() must be awaited first!");
8757 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
8758 return nativeResponseValue;
8760 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
8762 export function COption_CVec_NetAddressZZ_none(): number {
8763 if(!isWasmInitialized) {
8764 throw new Error("initializeWasm() must be awaited first!");
8766 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
8767 return nativeResponseValue;
8769 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
8771 export function COption_CVec_NetAddressZZ_free(_res: number): void {
8772 if(!isWasmInitialized) {
8773 throw new Error("initializeWasm() must be awaited first!");
8775 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
8776 // debug statements here
8778 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
8780 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
8781 if(!isWasmInitialized) {
8782 throw new Error("initializeWasm() must be awaited first!");
8784 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
8785 return nativeResponseValue;
8787 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
8789 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
8790 if(!isWasmInitialized) {
8791 throw new Error("initializeWasm() must be awaited first!");
8793 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
8794 return nativeResponseValue;
8796 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_ok(struct LDKScoringParameters o);
8798 export function CResult_ScoringParametersDecodeErrorZ_ok(o: number): number {
8799 if(!isWasmInitialized) {
8800 throw new Error("initializeWasm() must be awaited first!");
8802 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_ok(o);
8803 return nativeResponseValue;
8805 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8807 export function CResult_ScoringParametersDecodeErrorZ_err(e: number): number {
8808 if(!isWasmInitialized) {
8809 throw new Error("initializeWasm() must be awaited first!");
8811 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_err(e);
8812 return nativeResponseValue;
8814 // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
8816 export function CResult_ScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8817 if(!isWasmInitialized) {
8818 throw new Error("initializeWasm() must be awaited first!");
8820 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_is_ok(o);
8821 return nativeResponseValue;
8823 // void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
8825 export function CResult_ScoringParametersDecodeErrorZ_free(_res: number): void {
8826 if(!isWasmInitialized) {
8827 throw new Error("initializeWasm() must be awaited first!");
8829 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_free(_res);
8830 // debug statements here
8832 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8834 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8835 if(!isWasmInitialized) {
8836 throw new Error("initializeWasm() must be awaited first!");
8838 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8839 return nativeResponseValue;
8841 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8843 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8844 if(!isWasmInitialized) {
8845 throw new Error("initializeWasm() must be awaited first!");
8847 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8848 return nativeResponseValue;
8850 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8852 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8853 if(!isWasmInitialized) {
8854 throw new Error("initializeWasm() must be awaited first!");
8856 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8857 return nativeResponseValue;
8859 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8861 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8862 if(!isWasmInitialized) {
8863 throw new Error("initializeWasm() must be awaited first!");
8865 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8866 // debug statements here
8868 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8870 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8871 if(!isWasmInitialized) {
8872 throw new Error("initializeWasm() must be awaited first!");
8874 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8875 return nativeResponseValue;
8877 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8879 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8880 if(!isWasmInitialized) {
8881 throw new Error("initializeWasm() must be awaited first!");
8883 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8884 return nativeResponseValue;
8886 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8888 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8889 if(!isWasmInitialized) {
8890 throw new Error("initializeWasm() must be awaited first!");
8892 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8893 return nativeResponseValue;
8895 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8897 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8898 if(!isWasmInitialized) {
8899 throw new Error("initializeWasm() must be awaited first!");
8901 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8902 // debug statements here
8904 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8906 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8907 if(!isWasmInitialized) {
8908 throw new Error("initializeWasm() must be awaited first!");
8910 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8911 return nativeResponseValue;
8913 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8915 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8916 if(!isWasmInitialized) {
8917 throw new Error("initializeWasm() must be awaited first!");
8919 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8920 return nativeResponseValue;
8922 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8924 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8925 if(!isWasmInitialized) {
8926 throw new Error("initializeWasm() must be awaited first!");
8928 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8929 return nativeResponseValue;
8931 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8933 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8934 if(!isWasmInitialized) {
8935 throw new Error("initializeWasm() must be awaited first!");
8937 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8938 // debug statements here
8940 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8942 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8943 if(!isWasmInitialized) {
8944 throw new Error("initializeWasm() must be awaited first!");
8946 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8947 return nativeResponseValue;
8949 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8951 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8952 if(!isWasmInitialized) {
8953 throw new Error("initializeWasm() must be awaited first!");
8955 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8956 return nativeResponseValue;
8958 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8960 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8961 if(!isWasmInitialized) {
8962 throw new Error("initializeWasm() must be awaited first!");
8964 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8965 return nativeResponseValue;
8967 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8969 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8970 if(!isWasmInitialized) {
8971 throw new Error("initializeWasm() must be awaited first!");
8973 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8974 // debug statements here
8976 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8978 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8979 if(!isWasmInitialized) {
8980 throw new Error("initializeWasm() must be awaited first!");
8982 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
8983 return nativeResponseValue;
8985 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8987 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
8988 if(!isWasmInitialized) {
8989 throw new Error("initializeWasm() must be awaited first!");
8991 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
8992 return nativeResponseValue;
8994 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
8996 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8997 if(!isWasmInitialized) {
8998 throw new Error("initializeWasm() must be awaited first!");
9000 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9001 return nativeResponseValue;
9003 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9005 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
9006 if(!isWasmInitialized) {
9007 throw new Error("initializeWasm() must be awaited first!");
9009 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9010 // debug statements here
9012 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
9014 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
9015 if(!isWasmInitialized) {
9016 throw new Error("initializeWasm() must be awaited first!");
9018 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
9019 return nativeResponseValue;
9021 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
9023 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
9024 if(!isWasmInitialized) {
9025 throw new Error("initializeWasm() must be awaited first!");
9027 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
9028 return nativeResponseValue;
9030 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
9032 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
9033 if(!isWasmInitialized) {
9034 throw new Error("initializeWasm() must be awaited first!");
9036 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
9037 return nativeResponseValue;
9039 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
9041 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
9042 if(!isWasmInitialized) {
9043 throw new Error("initializeWasm() must be awaited first!");
9045 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
9046 // debug statements here
9048 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
9050 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
9051 if(!isWasmInitialized) {
9052 throw new Error("initializeWasm() must be awaited first!");
9054 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
9055 return nativeResponseValue;
9057 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
9059 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
9060 if(!isWasmInitialized) {
9061 throw new Error("initializeWasm() must be awaited first!");
9063 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
9064 return nativeResponseValue;
9066 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
9068 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
9069 if(!isWasmInitialized) {
9070 throw new Error("initializeWasm() must be awaited first!");
9072 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
9073 // debug statements here
9075 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
9077 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
9078 if(!isWasmInitialized) {
9079 throw new Error("initializeWasm() must be awaited first!");
9081 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
9082 // debug statements here
9084 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
9086 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
9087 if(!isWasmInitialized) {
9088 throw new Error("initializeWasm() must be awaited first!");
9090 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
9091 // debug statements here
9093 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
9095 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
9096 if(!isWasmInitialized) {
9097 throw new Error("initializeWasm() must be awaited first!");
9099 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
9100 // debug statements here
9102 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
9104 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
9105 if(!isWasmInitialized) {
9106 throw new Error("initializeWasm() must be awaited first!");
9108 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
9109 return nativeResponseValue;
9111 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
9113 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
9114 if(!isWasmInitialized) {
9115 throw new Error("initializeWasm() must be awaited first!");
9117 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
9118 return nativeResponseValue;
9120 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
9122 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
9123 if(!isWasmInitialized) {
9124 throw new Error("initializeWasm() must be awaited first!");
9126 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
9127 return nativeResponseValue;
9129 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
9131 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
9132 if(!isWasmInitialized) {
9133 throw new Error("initializeWasm() must be awaited first!");
9135 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
9136 // debug statements here
9138 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
9140 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
9141 if(!isWasmInitialized) {
9142 throw new Error("initializeWasm() must be awaited first!");
9144 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
9145 return nativeResponseValue;
9147 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
9149 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
9150 if(!isWasmInitialized) {
9151 throw new Error("initializeWasm() must be awaited first!");
9153 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
9154 return nativeResponseValue;
9156 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
9158 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
9159 if(!isWasmInitialized) {
9160 throw new Error("initializeWasm() must be awaited first!");
9162 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
9163 return nativeResponseValue;
9165 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
9167 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
9168 if(!isWasmInitialized) {
9169 throw new Error("initializeWasm() must be awaited first!");
9171 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
9172 return nativeResponseValue;
9174 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
9176 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
9177 if(!isWasmInitialized) {
9178 throw new Error("initializeWasm() must be awaited first!");
9180 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
9181 return nativeResponseValue;
9183 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
9185 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
9186 if(!isWasmInitialized) {
9187 throw new Error("initializeWasm() must be awaited first!");
9189 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
9190 // debug statements here
9192 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
9194 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
9195 if(!isWasmInitialized) {
9196 throw new Error("initializeWasm() must be awaited first!");
9198 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
9199 return nativeResponseValue;
9201 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
9203 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
9204 if(!isWasmInitialized) {
9205 throw new Error("initializeWasm() must be awaited first!");
9207 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
9208 return nativeResponseValue;
9210 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
9212 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
9213 if(!isWasmInitialized) {
9214 throw new Error("initializeWasm() must be awaited first!");
9216 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
9217 return nativeResponseValue;
9219 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
9221 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
9222 if(!isWasmInitialized) {
9223 throw new Error("initializeWasm() must be awaited first!");
9225 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
9226 return nativeResponseValue;
9228 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
9230 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
9231 if(!isWasmInitialized) {
9232 throw new Error("initializeWasm() must be awaited first!");
9234 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
9235 return nativeResponseValue;
9237 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
9239 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
9240 if(!isWasmInitialized) {
9241 throw new Error("initializeWasm() must be awaited first!");
9243 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
9244 // debug statements here
9246 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
9248 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
9249 if(!isWasmInitialized) {
9250 throw new Error("initializeWasm() must be awaited first!");
9252 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
9253 return nativeResponseValue;
9255 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
9257 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
9258 if(!isWasmInitialized) {
9259 throw new Error("initializeWasm() must be awaited first!");
9261 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
9262 return nativeResponseValue;
9264 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
9266 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
9267 if(!isWasmInitialized) {
9268 throw new Error("initializeWasm() must be awaited first!");
9270 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
9271 return nativeResponseValue;
9273 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
9275 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
9276 if(!isWasmInitialized) {
9277 throw new Error("initializeWasm() must be awaited first!");
9279 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
9280 return nativeResponseValue;
9282 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
9284 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
9285 if(!isWasmInitialized) {
9286 throw new Error("initializeWasm() must be awaited first!");
9288 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
9289 return nativeResponseValue;
9291 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
9293 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
9294 if(!isWasmInitialized) {
9295 throw new Error("initializeWasm() must be awaited first!");
9297 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
9298 // debug statements here
9300 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
9302 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
9303 if(!isWasmInitialized) {
9304 throw new Error("initializeWasm() must be awaited first!");
9306 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
9307 return nativeResponseValue;
9309 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
9311 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
9312 if(!isWasmInitialized) {
9313 throw new Error("initializeWasm() must be awaited first!");
9315 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
9316 return nativeResponseValue;
9318 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
9320 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
9321 if(!isWasmInitialized) {
9322 throw new Error("initializeWasm() must be awaited first!");
9324 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
9325 return nativeResponseValue;
9327 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
9329 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
9330 if(!isWasmInitialized) {
9331 throw new Error("initializeWasm() must be awaited first!");
9333 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
9334 return nativeResponseValue;
9336 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
9338 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
9339 if(!isWasmInitialized) {
9340 throw new Error("initializeWasm() must be awaited first!");
9342 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
9343 return nativeResponseValue;
9345 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
9347 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
9348 if(!isWasmInitialized) {
9349 throw new Error("initializeWasm() must be awaited first!");
9351 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
9352 // debug statements here
9354 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
9356 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
9357 if(!isWasmInitialized) {
9358 throw new Error("initializeWasm() must be awaited first!");
9360 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
9361 return nativeResponseValue;
9363 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
9365 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
9366 if(!isWasmInitialized) {
9367 throw new Error("initializeWasm() must be awaited first!");
9369 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
9370 return nativeResponseValue;
9372 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
9374 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
9375 if(!isWasmInitialized) {
9376 throw new Error("initializeWasm() must be awaited first!");
9378 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
9379 return nativeResponseValue;
9381 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
9383 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
9384 if(!isWasmInitialized) {
9385 throw new Error("initializeWasm() must be awaited first!");
9387 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
9388 return nativeResponseValue;
9390 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
9392 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
9393 if(!isWasmInitialized) {
9394 throw new Error("initializeWasm() must be awaited first!");
9396 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
9397 return nativeResponseValue;
9399 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
9401 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
9402 if(!isWasmInitialized) {
9403 throw new Error("initializeWasm() must be awaited first!");
9405 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
9406 // debug statements here
9408 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
9410 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
9411 if(!isWasmInitialized) {
9412 throw new Error("initializeWasm() must be awaited first!");
9414 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
9415 return nativeResponseValue;
9417 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
9419 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
9420 if(!isWasmInitialized) {
9421 throw new Error("initializeWasm() must be awaited first!");
9423 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
9424 return nativeResponseValue;
9426 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
9428 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
9429 if(!isWasmInitialized) {
9430 throw new Error("initializeWasm() must be awaited first!");
9432 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
9433 return nativeResponseValue;
9435 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
9437 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
9438 if(!isWasmInitialized) {
9439 throw new Error("initializeWasm() must be awaited first!");
9441 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
9442 return nativeResponseValue;
9444 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
9446 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
9447 if(!isWasmInitialized) {
9448 throw new Error("initializeWasm() must be awaited first!");
9450 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
9451 return nativeResponseValue;
9453 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
9455 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
9456 if(!isWasmInitialized) {
9457 throw new Error("initializeWasm() must be awaited first!");
9459 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
9460 // debug statements here
9462 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
9464 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
9465 if(!isWasmInitialized) {
9466 throw new Error("initializeWasm() must be awaited first!");
9468 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
9469 return nativeResponseValue;
9471 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
9473 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
9474 if(!isWasmInitialized) {
9475 throw new Error("initializeWasm() must be awaited first!");
9477 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
9478 return nativeResponseValue;
9480 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
9482 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
9483 if(!isWasmInitialized) {
9484 throw new Error("initializeWasm() must be awaited first!");
9486 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
9487 return nativeResponseValue;
9489 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
9491 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
9492 if(!isWasmInitialized) {
9493 throw new Error("initializeWasm() must be awaited first!");
9495 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
9496 return nativeResponseValue;
9498 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
9500 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
9501 if(!isWasmInitialized) {
9502 throw new Error("initializeWasm() must be awaited first!");
9504 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
9505 return nativeResponseValue;
9507 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
9509 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
9510 if(!isWasmInitialized) {
9511 throw new Error("initializeWasm() must be awaited first!");
9513 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
9514 // debug statements here
9516 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
9518 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
9519 if(!isWasmInitialized) {
9520 throw new Error("initializeWasm() must be awaited first!");
9522 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
9523 return nativeResponseValue;
9525 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
9527 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
9528 if(!isWasmInitialized) {
9529 throw new Error("initializeWasm() must be awaited first!");
9531 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
9532 return nativeResponseValue;
9534 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
9536 export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
9537 if(!isWasmInitialized) {
9538 throw new Error("initializeWasm() must be awaited first!");
9540 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_ok(o);
9541 return nativeResponseValue;
9543 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
9545 export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
9546 if(!isWasmInitialized) {
9547 throw new Error("initializeWasm() must be awaited first!");
9549 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_err(e);
9550 return nativeResponseValue;
9552 // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
9554 export function CResult_FundingLockedDecodeErrorZ_is_ok(o: number): boolean {
9555 if(!isWasmInitialized) {
9556 throw new Error("initializeWasm() must be awaited first!");
9558 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_is_ok(o);
9559 return nativeResponseValue;
9561 // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
9563 export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
9564 if(!isWasmInitialized) {
9565 throw new Error("initializeWasm() must be awaited first!");
9567 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_free(_res);
9568 // debug statements here
9570 // uintptr_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
9572 export function CResult_FundingLockedDecodeErrorZ_clone_ptr(arg: number): number {
9573 if(!isWasmInitialized) {
9574 throw new Error("initializeWasm() must be awaited first!");
9576 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(arg);
9577 return nativeResponseValue;
9579 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
9581 export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
9582 if(!isWasmInitialized) {
9583 throw new Error("initializeWasm() must be awaited first!");
9585 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone(orig);
9586 return nativeResponseValue;
9588 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
9590 export function CResult_InitDecodeErrorZ_ok(o: number): number {
9591 if(!isWasmInitialized) {
9592 throw new Error("initializeWasm() must be awaited first!");
9594 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
9595 return nativeResponseValue;
9597 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
9599 export function CResult_InitDecodeErrorZ_err(e: number): number {
9600 if(!isWasmInitialized) {
9601 throw new Error("initializeWasm() must be awaited first!");
9603 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
9604 return nativeResponseValue;
9606 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
9608 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
9609 if(!isWasmInitialized) {
9610 throw new Error("initializeWasm() must be awaited first!");
9612 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
9613 return nativeResponseValue;
9615 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
9617 export function CResult_InitDecodeErrorZ_free(_res: number): void {
9618 if(!isWasmInitialized) {
9619 throw new Error("initializeWasm() must be awaited first!");
9621 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
9622 // debug statements here
9624 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
9626 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
9627 if(!isWasmInitialized) {
9628 throw new Error("initializeWasm() must be awaited first!");
9630 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
9631 return nativeResponseValue;
9633 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
9635 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
9636 if(!isWasmInitialized) {
9637 throw new Error("initializeWasm() must be awaited first!");
9639 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
9640 return nativeResponseValue;
9642 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
9644 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
9645 if(!isWasmInitialized) {
9646 throw new Error("initializeWasm() must be awaited first!");
9648 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
9649 return nativeResponseValue;
9651 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
9653 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
9654 if(!isWasmInitialized) {
9655 throw new Error("initializeWasm() must be awaited first!");
9657 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
9658 return nativeResponseValue;
9660 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
9662 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
9663 if(!isWasmInitialized) {
9664 throw new Error("initializeWasm() must be awaited first!");
9666 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
9667 return nativeResponseValue;
9669 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
9671 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
9672 if(!isWasmInitialized) {
9673 throw new Error("initializeWasm() must be awaited first!");
9675 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
9676 // debug statements here
9678 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
9680 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
9681 if(!isWasmInitialized) {
9682 throw new Error("initializeWasm() must be awaited first!");
9684 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
9685 return nativeResponseValue;
9687 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
9689 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
9690 if(!isWasmInitialized) {
9691 throw new Error("initializeWasm() must be awaited first!");
9693 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
9694 return nativeResponseValue;
9696 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
9698 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
9699 if(!isWasmInitialized) {
9700 throw new Error("initializeWasm() must be awaited first!");
9702 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
9703 return nativeResponseValue;
9705 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
9707 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
9708 if(!isWasmInitialized) {
9709 throw new Error("initializeWasm() must be awaited first!");
9711 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
9712 return nativeResponseValue;
9714 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
9716 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
9717 if(!isWasmInitialized) {
9718 throw new Error("initializeWasm() must be awaited first!");
9720 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
9721 return nativeResponseValue;
9723 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
9725 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
9726 if(!isWasmInitialized) {
9727 throw new Error("initializeWasm() must be awaited first!");
9729 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
9730 // debug statements here
9732 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
9734 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
9735 if(!isWasmInitialized) {
9736 throw new Error("initializeWasm() must be awaited first!");
9738 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
9739 return nativeResponseValue;
9741 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
9743 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
9744 if(!isWasmInitialized) {
9745 throw new Error("initializeWasm() must be awaited first!");
9747 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
9748 return nativeResponseValue;
9750 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
9752 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
9753 if(!isWasmInitialized) {
9754 throw new Error("initializeWasm() must be awaited first!");
9756 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
9757 return nativeResponseValue;
9759 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
9761 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
9762 if(!isWasmInitialized) {
9763 throw new Error("initializeWasm() must be awaited first!");
9765 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
9766 return nativeResponseValue;
9768 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
9770 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
9771 if(!isWasmInitialized) {
9772 throw new Error("initializeWasm() must be awaited first!");
9774 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
9775 return nativeResponseValue;
9777 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
9779 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
9780 if(!isWasmInitialized) {
9781 throw new Error("initializeWasm() must be awaited first!");
9783 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
9784 // debug statements here
9786 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
9788 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
9789 if(!isWasmInitialized) {
9790 throw new Error("initializeWasm() must be awaited first!");
9792 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
9793 return nativeResponseValue;
9795 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
9797 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
9798 if(!isWasmInitialized) {
9799 throw new Error("initializeWasm() must be awaited first!");
9801 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
9802 return nativeResponseValue;
9804 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
9806 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
9807 if(!isWasmInitialized) {
9808 throw new Error("initializeWasm() must be awaited first!");
9810 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
9811 return nativeResponseValue;
9813 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
9815 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
9816 if(!isWasmInitialized) {
9817 throw new Error("initializeWasm() must be awaited first!");
9819 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
9820 return nativeResponseValue;
9822 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
9824 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
9825 if(!isWasmInitialized) {
9826 throw new Error("initializeWasm() must be awaited first!");
9828 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
9829 return nativeResponseValue;
9831 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
9833 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
9834 if(!isWasmInitialized) {
9835 throw new Error("initializeWasm() must be awaited first!");
9837 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
9838 // debug statements here
9840 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
9842 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
9843 if(!isWasmInitialized) {
9844 throw new Error("initializeWasm() must be awaited first!");
9846 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
9847 return nativeResponseValue;
9849 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
9851 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
9852 if(!isWasmInitialized) {
9853 throw new Error("initializeWasm() must be awaited first!");
9855 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
9856 return nativeResponseValue;
9858 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
9860 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
9861 if(!isWasmInitialized) {
9862 throw new Error("initializeWasm() must be awaited first!");
9864 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
9865 return nativeResponseValue;
9867 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
9869 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
9870 if(!isWasmInitialized) {
9871 throw new Error("initializeWasm() must be awaited first!");
9873 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
9874 return nativeResponseValue;
9876 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
9878 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
9879 if(!isWasmInitialized) {
9880 throw new Error("initializeWasm() must be awaited first!");
9882 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
9883 return nativeResponseValue;
9885 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
9887 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
9888 if(!isWasmInitialized) {
9889 throw new Error("initializeWasm() must be awaited first!");
9891 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
9892 // debug statements here
9894 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
9896 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
9897 if(!isWasmInitialized) {
9898 throw new Error("initializeWasm() must be awaited first!");
9900 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
9901 return nativeResponseValue;
9903 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
9905 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
9906 if(!isWasmInitialized) {
9907 throw new Error("initializeWasm() must be awaited first!");
9909 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
9910 return nativeResponseValue;
9912 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
9914 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
9915 if(!isWasmInitialized) {
9916 throw new Error("initializeWasm() must be awaited first!");
9918 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
9919 return nativeResponseValue;
9921 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
9923 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
9924 if(!isWasmInitialized) {
9925 throw new Error("initializeWasm() must be awaited first!");
9927 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
9928 return nativeResponseValue;
9930 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
9932 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
9933 if(!isWasmInitialized) {
9934 throw new Error("initializeWasm() must be awaited first!");
9936 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
9937 return nativeResponseValue;
9939 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
9941 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
9942 if(!isWasmInitialized) {
9943 throw new Error("initializeWasm() must be awaited first!");
9945 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
9946 // debug statements here
9948 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
9950 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
9951 if(!isWasmInitialized) {
9952 throw new Error("initializeWasm() must be awaited first!");
9954 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
9955 return nativeResponseValue;
9957 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
9959 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
9960 if(!isWasmInitialized) {
9961 throw new Error("initializeWasm() must be awaited first!");
9963 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
9964 return nativeResponseValue;
9966 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
9968 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
9969 if(!isWasmInitialized) {
9970 throw new Error("initializeWasm() must be awaited first!");
9972 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
9973 return nativeResponseValue;
9975 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
9977 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
9978 if(!isWasmInitialized) {
9979 throw new Error("initializeWasm() must be awaited first!");
9981 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
9982 return nativeResponseValue;
9984 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
9986 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
9987 if(!isWasmInitialized) {
9988 throw new Error("initializeWasm() must be awaited first!");
9990 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
9991 return nativeResponseValue;
9993 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
9995 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
9996 if(!isWasmInitialized) {
9997 throw new Error("initializeWasm() must be awaited first!");
9999 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
10000 // debug statements here
10002 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
10004 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
10005 if(!isWasmInitialized) {
10006 throw new Error("initializeWasm() must be awaited first!");
10008 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
10009 return nativeResponseValue;
10011 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
10013 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
10014 if(!isWasmInitialized) {
10015 throw new Error("initializeWasm() must be awaited first!");
10017 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
10018 return nativeResponseValue;
10020 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
10022 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
10023 if(!isWasmInitialized) {
10024 throw new Error("initializeWasm() must be awaited first!");
10026 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
10027 return nativeResponseValue;
10029 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
10031 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
10032 if(!isWasmInitialized) {
10033 throw new Error("initializeWasm() must be awaited first!");
10035 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
10036 return nativeResponseValue;
10038 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
10040 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
10041 if(!isWasmInitialized) {
10042 throw new Error("initializeWasm() must be awaited first!");
10044 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
10045 return nativeResponseValue;
10047 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
10049 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
10050 if(!isWasmInitialized) {
10051 throw new Error("initializeWasm() must be awaited first!");
10053 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
10054 // debug statements here
10056 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
10058 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
10059 if(!isWasmInitialized) {
10060 throw new Error("initializeWasm() must be awaited first!");
10062 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
10063 return nativeResponseValue;
10065 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
10067 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
10068 if(!isWasmInitialized) {
10069 throw new Error("initializeWasm() must be awaited first!");
10071 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
10072 return nativeResponseValue;
10074 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
10076 export function CResult_PingDecodeErrorZ_ok(o: number): number {
10077 if(!isWasmInitialized) {
10078 throw new Error("initializeWasm() must be awaited first!");
10080 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
10081 return nativeResponseValue;
10083 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
10085 export function CResult_PingDecodeErrorZ_err(e: number): number {
10086 if(!isWasmInitialized) {
10087 throw new Error("initializeWasm() must be awaited first!");
10089 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
10090 return nativeResponseValue;
10092 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
10094 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
10095 if(!isWasmInitialized) {
10096 throw new Error("initializeWasm() must be awaited first!");
10098 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
10099 return nativeResponseValue;
10101 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
10103 export function CResult_PingDecodeErrorZ_free(_res: number): void {
10104 if(!isWasmInitialized) {
10105 throw new Error("initializeWasm() must be awaited first!");
10107 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
10108 // debug statements here
10110 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
10112 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
10113 if(!isWasmInitialized) {
10114 throw new Error("initializeWasm() must be awaited first!");
10116 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
10117 return nativeResponseValue;
10119 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
10121 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
10122 if(!isWasmInitialized) {
10123 throw new Error("initializeWasm() must be awaited first!");
10125 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
10126 return nativeResponseValue;
10128 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
10130 export function CResult_PongDecodeErrorZ_ok(o: number): number {
10131 if(!isWasmInitialized) {
10132 throw new Error("initializeWasm() must be awaited first!");
10134 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
10135 return nativeResponseValue;
10137 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
10139 export function CResult_PongDecodeErrorZ_err(e: number): number {
10140 if(!isWasmInitialized) {
10141 throw new Error("initializeWasm() must be awaited first!");
10143 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
10144 return nativeResponseValue;
10146 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
10148 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
10149 if(!isWasmInitialized) {
10150 throw new Error("initializeWasm() must be awaited first!");
10152 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
10153 return nativeResponseValue;
10155 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
10157 export function CResult_PongDecodeErrorZ_free(_res: number): void {
10158 if(!isWasmInitialized) {
10159 throw new Error("initializeWasm() must be awaited first!");
10161 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
10162 // debug statements here
10164 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
10166 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
10167 if(!isWasmInitialized) {
10168 throw new Error("initializeWasm() must be awaited first!");
10170 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
10171 return nativeResponseValue;
10173 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
10175 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
10176 if(!isWasmInitialized) {
10177 throw new Error("initializeWasm() must be awaited first!");
10179 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
10180 return nativeResponseValue;
10182 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
10184 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
10185 if(!isWasmInitialized) {
10186 throw new Error("initializeWasm() must be awaited first!");
10188 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
10189 return nativeResponseValue;
10191 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10193 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
10194 if(!isWasmInitialized) {
10195 throw new Error("initializeWasm() must be awaited first!");
10197 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
10198 return nativeResponseValue;
10200 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
10202 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10203 if(!isWasmInitialized) {
10204 throw new Error("initializeWasm() must be awaited first!");
10206 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
10207 return nativeResponseValue;
10209 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
10211 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
10212 if(!isWasmInitialized) {
10213 throw new Error("initializeWasm() must be awaited first!");
10215 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
10216 // debug statements here
10218 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10220 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10221 if(!isWasmInitialized) {
10222 throw new Error("initializeWasm() must be awaited first!");
10224 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
10225 return nativeResponseValue;
10227 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10229 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
10230 if(!isWasmInitialized) {
10231 throw new Error("initializeWasm() must be awaited first!");
10233 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
10234 return nativeResponseValue;
10236 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
10238 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
10239 if(!isWasmInitialized) {
10240 throw new Error("initializeWasm() must be awaited first!");
10242 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
10243 return nativeResponseValue;
10245 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10247 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
10248 if(!isWasmInitialized) {
10249 throw new Error("initializeWasm() must be awaited first!");
10251 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
10252 return nativeResponseValue;
10254 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
10256 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10257 if(!isWasmInitialized) {
10258 throw new Error("initializeWasm() must be awaited first!");
10260 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
10261 return nativeResponseValue;
10263 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
10265 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
10266 if(!isWasmInitialized) {
10267 throw new Error("initializeWasm() must be awaited first!");
10269 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
10270 // debug statements here
10272 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10274 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10275 if(!isWasmInitialized) {
10276 throw new Error("initializeWasm() must be awaited first!");
10278 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
10279 return nativeResponseValue;
10281 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10283 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
10284 if(!isWasmInitialized) {
10285 throw new Error("initializeWasm() must be awaited first!");
10287 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
10288 return nativeResponseValue;
10290 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
10292 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
10293 if(!isWasmInitialized) {
10294 throw new Error("initializeWasm() must be awaited first!");
10296 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
10297 return nativeResponseValue;
10299 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
10301 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
10302 if(!isWasmInitialized) {
10303 throw new Error("initializeWasm() must be awaited first!");
10305 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
10306 return nativeResponseValue;
10308 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
10310 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
10311 if(!isWasmInitialized) {
10312 throw new Error("initializeWasm() must be awaited first!");
10314 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
10315 return nativeResponseValue;
10317 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
10319 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
10320 if(!isWasmInitialized) {
10321 throw new Error("initializeWasm() must be awaited first!");
10323 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
10324 // debug statements here
10326 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
10328 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
10329 if(!isWasmInitialized) {
10330 throw new Error("initializeWasm() must be awaited first!");
10332 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
10333 return nativeResponseValue;
10335 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
10337 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
10338 if(!isWasmInitialized) {
10339 throw new Error("initializeWasm() must be awaited first!");
10341 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
10342 return nativeResponseValue;
10344 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
10346 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
10347 if(!isWasmInitialized) {
10348 throw new Error("initializeWasm() must be awaited first!");
10350 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
10351 return nativeResponseValue;
10353 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
10355 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
10356 if(!isWasmInitialized) {
10357 throw new Error("initializeWasm() must be awaited first!");
10359 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
10360 return nativeResponseValue;
10362 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
10364 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
10365 if(!isWasmInitialized) {
10366 throw new Error("initializeWasm() must be awaited first!");
10368 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
10369 return nativeResponseValue;
10371 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
10373 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
10374 if(!isWasmInitialized) {
10375 throw new Error("initializeWasm() must be awaited first!");
10377 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
10378 // debug statements here
10380 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
10382 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
10383 if(!isWasmInitialized) {
10384 throw new Error("initializeWasm() must be awaited first!");
10386 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
10387 return nativeResponseValue;
10389 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
10391 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
10392 if(!isWasmInitialized) {
10393 throw new Error("initializeWasm() must be awaited first!");
10395 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
10396 return nativeResponseValue;
10398 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
10400 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
10401 if(!isWasmInitialized) {
10402 throw new Error("initializeWasm() must be awaited first!");
10404 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
10405 return nativeResponseValue;
10407 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
10409 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
10410 if(!isWasmInitialized) {
10411 throw new Error("initializeWasm() must be awaited first!");
10413 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
10414 return nativeResponseValue;
10416 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
10418 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
10419 if(!isWasmInitialized) {
10420 throw new Error("initializeWasm() must be awaited first!");
10422 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
10423 return nativeResponseValue;
10425 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
10427 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
10428 if(!isWasmInitialized) {
10429 throw new Error("initializeWasm() must be awaited first!");
10431 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
10432 // debug statements here
10434 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
10436 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
10437 if(!isWasmInitialized) {
10438 throw new Error("initializeWasm() must be awaited first!");
10440 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
10441 return nativeResponseValue;
10443 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
10445 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
10446 if(!isWasmInitialized) {
10447 throw new Error("initializeWasm() must be awaited first!");
10449 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
10450 return nativeResponseValue;
10452 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
10454 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
10455 if(!isWasmInitialized) {
10456 throw new Error("initializeWasm() must be awaited first!");
10458 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
10459 return nativeResponseValue;
10461 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10463 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
10464 if(!isWasmInitialized) {
10465 throw new Error("initializeWasm() must be awaited first!");
10467 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
10468 return nativeResponseValue;
10470 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
10472 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10473 if(!isWasmInitialized) {
10474 throw new Error("initializeWasm() must be awaited first!");
10476 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
10477 return nativeResponseValue;
10479 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
10481 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
10482 if(!isWasmInitialized) {
10483 throw new Error("initializeWasm() must be awaited first!");
10485 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
10486 // debug statements here
10488 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10490 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10491 if(!isWasmInitialized) {
10492 throw new Error("initializeWasm() must be awaited first!");
10494 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
10495 return nativeResponseValue;
10497 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10499 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
10500 if(!isWasmInitialized) {
10501 throw new Error("initializeWasm() must be awaited first!");
10503 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
10504 return nativeResponseValue;
10506 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
10508 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
10509 if(!isWasmInitialized) {
10510 throw new Error("initializeWasm() must be awaited first!");
10512 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
10513 return nativeResponseValue;
10515 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
10517 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
10518 if(!isWasmInitialized) {
10519 throw new Error("initializeWasm() must be awaited first!");
10521 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
10522 return nativeResponseValue;
10524 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
10526 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
10527 if(!isWasmInitialized) {
10528 throw new Error("initializeWasm() must be awaited first!");
10530 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
10531 return nativeResponseValue;
10533 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
10535 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
10536 if(!isWasmInitialized) {
10537 throw new Error("initializeWasm() must be awaited first!");
10539 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
10540 // debug statements here
10542 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
10544 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
10545 if(!isWasmInitialized) {
10546 throw new Error("initializeWasm() must be awaited first!");
10548 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
10549 return nativeResponseValue;
10551 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
10553 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
10554 if(!isWasmInitialized) {
10555 throw new Error("initializeWasm() must be awaited first!");
10557 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
10558 return nativeResponseValue;
10560 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
10562 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
10563 if(!isWasmInitialized) {
10564 throw new Error("initializeWasm() must be awaited first!");
10566 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
10567 return nativeResponseValue;
10569 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
10571 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
10572 if(!isWasmInitialized) {
10573 throw new Error("initializeWasm() must be awaited first!");
10575 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
10576 return nativeResponseValue;
10578 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
10580 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
10581 if(!isWasmInitialized) {
10582 throw new Error("initializeWasm() must be awaited first!");
10584 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
10585 return nativeResponseValue;
10587 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
10589 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
10590 if(!isWasmInitialized) {
10591 throw new Error("initializeWasm() must be awaited first!");
10593 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
10594 // debug statements here
10596 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
10598 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
10599 if(!isWasmInitialized) {
10600 throw new Error("initializeWasm() must be awaited first!");
10602 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
10603 return nativeResponseValue;
10605 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
10607 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
10608 if(!isWasmInitialized) {
10609 throw new Error("initializeWasm() must be awaited first!");
10611 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
10612 return nativeResponseValue;
10614 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
10616 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
10617 if(!isWasmInitialized) {
10618 throw new Error("initializeWasm() must be awaited first!");
10620 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
10621 return nativeResponseValue;
10623 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
10625 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
10626 if(!isWasmInitialized) {
10627 throw new Error("initializeWasm() must be awaited first!");
10629 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
10630 return nativeResponseValue;
10632 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
10634 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
10635 if(!isWasmInitialized) {
10636 throw new Error("initializeWasm() must be awaited first!");
10638 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
10639 return nativeResponseValue;
10641 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
10643 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
10644 if(!isWasmInitialized) {
10645 throw new Error("initializeWasm() must be awaited first!");
10647 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
10648 // debug statements here
10650 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
10652 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
10653 if(!isWasmInitialized) {
10654 throw new Error("initializeWasm() must be awaited first!");
10656 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
10657 return nativeResponseValue;
10659 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
10661 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
10662 if(!isWasmInitialized) {
10663 throw new Error("initializeWasm() must be awaited first!");
10665 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
10666 return nativeResponseValue;
10668 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
10670 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
10671 if(!isWasmInitialized) {
10672 throw new Error("initializeWasm() must be awaited first!");
10674 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
10675 return nativeResponseValue;
10677 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
10679 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
10680 if(!isWasmInitialized) {
10681 throw new Error("initializeWasm() must be awaited first!");
10683 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
10684 return nativeResponseValue;
10686 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
10688 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
10689 if(!isWasmInitialized) {
10690 throw new Error("initializeWasm() must be awaited first!");
10692 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
10693 return nativeResponseValue;
10695 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
10697 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
10698 if(!isWasmInitialized) {
10699 throw new Error("initializeWasm() must be awaited first!");
10701 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
10702 // debug statements here
10704 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
10706 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
10707 if(!isWasmInitialized) {
10708 throw new Error("initializeWasm() must be awaited first!");
10710 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
10711 return nativeResponseValue;
10713 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
10715 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
10716 if(!isWasmInitialized) {
10717 throw new Error("initializeWasm() must be awaited first!");
10719 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
10720 return nativeResponseValue;
10722 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
10724 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
10725 if(!isWasmInitialized) {
10726 throw new Error("initializeWasm() must be awaited first!");
10728 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
10729 return nativeResponseValue;
10731 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
10733 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
10734 if(!isWasmInitialized) {
10735 throw new Error("initializeWasm() must be awaited first!");
10737 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
10738 return nativeResponseValue;
10740 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
10742 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
10743 if(!isWasmInitialized) {
10744 throw new Error("initializeWasm() must be awaited first!");
10746 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
10747 return nativeResponseValue;
10749 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
10751 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
10752 if(!isWasmInitialized) {
10753 throw new Error("initializeWasm() must be awaited first!");
10755 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
10756 // debug statements here
10758 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
10760 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
10761 if(!isWasmInitialized) {
10762 throw new Error("initializeWasm() must be awaited first!");
10764 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
10765 return nativeResponseValue;
10767 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
10769 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
10770 if(!isWasmInitialized) {
10771 throw new Error("initializeWasm() must be awaited first!");
10773 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
10774 return nativeResponseValue;
10776 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
10778 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
10779 if(!isWasmInitialized) {
10780 throw new Error("initializeWasm() must be awaited first!");
10782 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
10783 return nativeResponseValue;
10785 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
10787 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
10788 if(!isWasmInitialized) {
10789 throw new Error("initializeWasm() must be awaited first!");
10791 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
10792 return nativeResponseValue;
10794 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
10796 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
10797 if(!isWasmInitialized) {
10798 throw new Error("initializeWasm() must be awaited first!");
10800 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
10801 return nativeResponseValue;
10803 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
10805 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
10806 if(!isWasmInitialized) {
10807 throw new Error("initializeWasm() must be awaited first!");
10809 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
10810 // debug statements here
10812 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
10814 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
10815 if(!isWasmInitialized) {
10816 throw new Error("initializeWasm() must be awaited first!");
10818 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
10819 return nativeResponseValue;
10821 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
10823 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
10824 if(!isWasmInitialized) {
10825 throw new Error("initializeWasm() must be awaited first!");
10827 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
10828 return nativeResponseValue;
10830 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10832 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10833 if(!isWasmInitialized) {
10834 throw new Error("initializeWasm() must be awaited first!");
10836 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10837 return nativeResponseValue;
10839 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10841 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10842 if(!isWasmInitialized) {
10843 throw new Error("initializeWasm() must be awaited first!");
10845 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10846 return nativeResponseValue;
10848 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10850 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10851 if(!isWasmInitialized) {
10852 throw new Error("initializeWasm() must be awaited first!");
10854 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10855 return nativeResponseValue;
10857 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10859 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10860 if(!isWasmInitialized) {
10861 throw new Error("initializeWasm() must be awaited first!");
10863 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10864 // debug statements here
10866 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10868 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10869 if(!isWasmInitialized) {
10870 throw new Error("initializeWasm() must be awaited first!");
10872 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10873 return nativeResponseValue;
10875 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10877 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10878 if(!isWasmInitialized) {
10879 throw new Error("initializeWasm() must be awaited first!");
10881 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10882 return nativeResponseValue;
10884 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10886 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10887 if(!isWasmInitialized) {
10888 throw new Error("initializeWasm() must be awaited first!");
10890 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10891 return nativeResponseValue;
10893 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10895 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10896 if(!isWasmInitialized) {
10897 throw new Error("initializeWasm() must be awaited first!");
10899 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
10900 return nativeResponseValue;
10902 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10904 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10905 if(!isWasmInitialized) {
10906 throw new Error("initializeWasm() must be awaited first!");
10908 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10909 return nativeResponseValue;
10911 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
10913 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10914 if(!isWasmInitialized) {
10915 throw new Error("initializeWasm() must be awaited first!");
10917 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
10918 // debug statements here
10920 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10922 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10923 if(!isWasmInitialized) {
10924 throw new Error("initializeWasm() must be awaited first!");
10926 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10927 return nativeResponseValue;
10929 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10931 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10932 if(!isWasmInitialized) {
10933 throw new Error("initializeWasm() must be awaited first!");
10935 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10936 return nativeResponseValue;
10938 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
10940 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
10941 if(!isWasmInitialized) {
10942 throw new Error("initializeWasm() must be awaited first!");
10944 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
10945 return nativeResponseValue;
10947 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10949 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
10950 if(!isWasmInitialized) {
10951 throw new Error("initializeWasm() must be awaited first!");
10953 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
10954 return nativeResponseValue;
10956 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10958 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10959 if(!isWasmInitialized) {
10960 throw new Error("initializeWasm() must be awaited first!");
10962 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
10963 return nativeResponseValue;
10965 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
10967 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
10968 if(!isWasmInitialized) {
10969 throw new Error("initializeWasm() must be awaited first!");
10971 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10972 // debug statements here
10974 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10976 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10977 if(!isWasmInitialized) {
10978 throw new Error("initializeWasm() must be awaited first!");
10980 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10981 return nativeResponseValue;
10983 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10985 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10986 if(!isWasmInitialized) {
10987 throw new Error("initializeWasm() must be awaited first!");
10989 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
10990 return nativeResponseValue;
10992 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10994 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
10995 if(!isWasmInitialized) {
10996 throw new Error("initializeWasm() must be awaited first!");
10998 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10999 return nativeResponseValue;
11001 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
11003 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
11004 if(!isWasmInitialized) {
11005 throw new Error("initializeWasm() must be awaited first!");
11007 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
11008 return nativeResponseValue;
11010 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
11012 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
11013 if(!isWasmInitialized) {
11014 throw new Error("initializeWasm() must be awaited first!");
11016 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
11017 return nativeResponseValue;
11019 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
11021 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
11022 if(!isWasmInitialized) {
11023 throw new Error("initializeWasm() must be awaited first!");
11025 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
11026 // debug statements here
11028 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
11030 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
11031 if(!isWasmInitialized) {
11032 throw new Error("initializeWasm() must be awaited first!");
11034 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
11035 return nativeResponseValue;
11037 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
11039 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
11040 if(!isWasmInitialized) {
11041 throw new Error("initializeWasm() must be awaited first!");
11043 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
11044 return nativeResponseValue;
11046 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
11048 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
11049 if(!isWasmInitialized) {
11050 throw new Error("initializeWasm() must be awaited first!");
11052 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
11053 return nativeResponseValue;
11055 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
11057 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
11058 if(!isWasmInitialized) {
11059 throw new Error("initializeWasm() must be awaited first!");
11061 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
11062 // debug statements here
11064 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
11066 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
11067 if(!isWasmInitialized) {
11068 throw new Error("initializeWasm() must be awaited first!");
11070 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
11071 return nativeResponseValue;
11073 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
11075 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
11076 if(!isWasmInitialized) {
11077 throw new Error("initializeWasm() must be awaited first!");
11079 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
11080 return nativeResponseValue;
11082 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
11084 export function CResult_SignatureNoneZ_ok(o: number): number {
11085 if(!isWasmInitialized) {
11086 throw new Error("initializeWasm() must be awaited first!");
11088 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
11089 return nativeResponseValue;
11091 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
11093 export function CResult_SignatureNoneZ_err(): number {
11094 if(!isWasmInitialized) {
11095 throw new Error("initializeWasm() must be awaited first!");
11097 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
11098 return nativeResponseValue;
11100 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
11102 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
11103 if(!isWasmInitialized) {
11104 throw new Error("initializeWasm() must be awaited first!");
11106 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
11107 return nativeResponseValue;
11109 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
11111 export function CResult_SignatureNoneZ_free(_res: number): void {
11112 if(!isWasmInitialized) {
11113 throw new Error("initializeWasm() must be awaited first!");
11115 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
11116 // debug statements here
11118 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
11120 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
11121 if(!isWasmInitialized) {
11122 throw new Error("initializeWasm() must be awaited first!");
11124 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
11125 return nativeResponseValue;
11127 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
11129 export function CResult_SignatureNoneZ_clone(orig: number): number {
11130 if(!isWasmInitialized) {
11131 throw new Error("initializeWasm() must be awaited first!");
11133 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
11134 return nativeResponseValue;
11136 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
11138 export function CResult_SignDecodeErrorZ_ok(o: number): number {
11139 if(!isWasmInitialized) {
11140 throw new Error("initializeWasm() must be awaited first!");
11142 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
11143 return nativeResponseValue;
11145 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
11147 export function CResult_SignDecodeErrorZ_err(e: number): number {
11148 if(!isWasmInitialized) {
11149 throw new Error("initializeWasm() must be awaited first!");
11151 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
11152 return nativeResponseValue;
11154 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
11156 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
11157 if(!isWasmInitialized) {
11158 throw new Error("initializeWasm() must be awaited first!");
11160 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
11161 return nativeResponseValue;
11163 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
11165 export function CResult_SignDecodeErrorZ_free(_res: number): void {
11166 if(!isWasmInitialized) {
11167 throw new Error("initializeWasm() must be awaited first!");
11169 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
11170 // debug statements here
11172 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
11174 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
11175 if(!isWasmInitialized) {
11176 throw new Error("initializeWasm() must be awaited first!");
11178 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
11179 return nativeResponseValue;
11181 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
11183 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
11184 if(!isWasmInitialized) {
11185 throw new Error("initializeWasm() must be awaited first!");
11187 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
11188 return nativeResponseValue;
11190 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
11192 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
11193 if(!isWasmInitialized) {
11194 throw new Error("initializeWasm() must be awaited first!");
11196 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
11197 return nativeResponseValue;
11199 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
11201 export function CResult_RecoverableSignatureNoneZ_err(): number {
11202 if(!isWasmInitialized) {
11203 throw new Error("initializeWasm() must be awaited first!");
11205 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
11206 return nativeResponseValue;
11208 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
11210 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
11211 if(!isWasmInitialized) {
11212 throw new Error("initializeWasm() must be awaited first!");
11214 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
11215 return nativeResponseValue;
11217 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
11219 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
11220 if(!isWasmInitialized) {
11221 throw new Error("initializeWasm() must be awaited first!");
11223 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
11224 // debug statements here
11226 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
11228 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
11229 if(!isWasmInitialized) {
11230 throw new Error("initializeWasm() must be awaited first!");
11232 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
11233 return nativeResponseValue;
11235 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
11237 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
11238 if(!isWasmInitialized) {
11239 throw new Error("initializeWasm() must be awaited first!");
11241 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
11242 return nativeResponseValue;
11244 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
11246 export function CVec_CVec_u8ZZ_free(_res: number): void {
11247 if(!isWasmInitialized) {
11248 throw new Error("initializeWasm() must be awaited first!");
11250 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
11251 // debug statements here
11253 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
11255 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
11256 if(!isWasmInitialized) {
11257 throw new Error("initializeWasm() must be awaited first!");
11259 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
11260 return nativeResponseValue;
11262 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
11264 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
11265 if(!isWasmInitialized) {
11266 throw new Error("initializeWasm() must be awaited first!");
11268 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
11269 return nativeResponseValue;
11271 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
11273 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
11274 if(!isWasmInitialized) {
11275 throw new Error("initializeWasm() must be awaited first!");
11277 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
11278 return nativeResponseValue;
11280 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
11282 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
11283 if(!isWasmInitialized) {
11284 throw new Error("initializeWasm() must be awaited first!");
11286 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
11287 // debug statements here
11289 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
11291 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
11292 if(!isWasmInitialized) {
11293 throw new Error("initializeWasm() must be awaited first!");
11295 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
11296 return nativeResponseValue;
11298 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
11300 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
11301 if(!isWasmInitialized) {
11302 throw new Error("initializeWasm() must be awaited first!");
11304 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
11305 return nativeResponseValue;
11307 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
11309 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
11310 if(!isWasmInitialized) {
11311 throw new Error("initializeWasm() must be awaited first!");
11313 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
11314 return nativeResponseValue;
11316 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
11318 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
11319 if(!isWasmInitialized) {
11320 throw new Error("initializeWasm() must be awaited first!");
11322 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
11323 return nativeResponseValue;
11325 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
11327 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
11328 if(!isWasmInitialized) {
11329 throw new Error("initializeWasm() must be awaited first!");
11331 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
11332 return nativeResponseValue;
11334 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
11336 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
11337 if(!isWasmInitialized) {
11338 throw new Error("initializeWasm() must be awaited first!");
11340 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
11341 // debug statements here
11343 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
11345 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
11346 if(!isWasmInitialized) {
11347 throw new Error("initializeWasm() must be awaited first!");
11349 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
11350 return nativeResponseValue;
11352 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
11354 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
11355 if(!isWasmInitialized) {
11356 throw new Error("initializeWasm() must be awaited first!");
11358 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
11359 return nativeResponseValue;
11361 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
11363 export function CVec_TxOutZ_free(_res: number): void {
11364 if(!isWasmInitialized) {
11365 throw new Error("initializeWasm() must be awaited first!");
11367 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
11368 // debug statements here
11370 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
11372 export function CResult_TransactionNoneZ_ok(o: number): number {
11373 if(!isWasmInitialized) {
11374 throw new Error("initializeWasm() must be awaited first!");
11376 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
11377 return nativeResponseValue;
11379 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
11381 export function CResult_TransactionNoneZ_err(): number {
11382 if(!isWasmInitialized) {
11383 throw new Error("initializeWasm() must be awaited first!");
11385 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
11386 return nativeResponseValue;
11388 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
11390 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
11391 if(!isWasmInitialized) {
11392 throw new Error("initializeWasm() must be awaited first!");
11394 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
11395 return nativeResponseValue;
11397 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
11399 export function CResult_TransactionNoneZ_free(_res: number): void {
11400 if(!isWasmInitialized) {
11401 throw new Error("initializeWasm() must be awaited first!");
11403 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
11404 // debug statements here
11406 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
11408 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
11409 if(!isWasmInitialized) {
11410 throw new Error("initializeWasm() must be awaited first!");
11412 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
11413 return nativeResponseValue;
11415 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
11417 export function CResult_TransactionNoneZ_clone(orig: number): number {
11418 if(!isWasmInitialized) {
11419 throw new Error("initializeWasm() must be awaited first!");
11421 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
11422 return nativeResponseValue;
11424 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
11426 export function COption_FilterZ_some(o: number): number {
11427 if(!isWasmInitialized) {
11428 throw new Error("initializeWasm() must be awaited first!");
11430 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
11431 return nativeResponseValue;
11433 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
11435 export function COption_FilterZ_none(): number {
11436 if(!isWasmInitialized) {
11437 throw new Error("initializeWasm() must be awaited first!");
11439 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
11440 return nativeResponseValue;
11442 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
11444 export function COption_FilterZ_free(_res: number): void {
11445 if(!isWasmInitialized) {
11446 throw new Error("initializeWasm() must be awaited first!");
11448 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
11449 // debug statements here
11451 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
11453 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
11454 if(!isWasmInitialized) {
11455 throw new Error("initializeWasm() must be awaited first!");
11457 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
11458 return nativeResponseValue;
11460 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
11462 export function CResult_LockedChannelMonitorNoneZ_err(): number {
11463 if(!isWasmInitialized) {
11464 throw new Error("initializeWasm() must be awaited first!");
11466 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
11467 return nativeResponseValue;
11469 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
11471 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
11472 if(!isWasmInitialized) {
11473 throw new Error("initializeWasm() must be awaited first!");
11475 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
11476 return nativeResponseValue;
11478 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
11480 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
11481 if(!isWasmInitialized) {
11482 throw new Error("initializeWasm() must be awaited first!");
11484 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
11485 // debug statements here
11487 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
11489 export function CVec_OutPointZ_free(_res: number): void {
11490 if(!isWasmInitialized) {
11491 throw new Error("initializeWasm() must be awaited first!");
11493 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
11494 // debug statements here
11496 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
11498 export function CResult_NoneAPIErrorZ_ok(): number {
11499 if(!isWasmInitialized) {
11500 throw new Error("initializeWasm() must be awaited first!");
11502 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
11503 return nativeResponseValue;
11505 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
11507 export function CResult_NoneAPIErrorZ_err(e: number): number {
11508 if(!isWasmInitialized) {
11509 throw new Error("initializeWasm() must be awaited first!");
11511 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
11512 return nativeResponseValue;
11514 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
11516 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
11517 if(!isWasmInitialized) {
11518 throw new Error("initializeWasm() must be awaited first!");
11520 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
11521 return nativeResponseValue;
11523 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
11525 export function CResult_NoneAPIErrorZ_free(_res: number): void {
11526 if(!isWasmInitialized) {
11527 throw new Error("initializeWasm() must be awaited first!");
11529 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11530 // debug statements here
11532 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11534 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
11535 if(!isWasmInitialized) {
11536 throw new Error("initializeWasm() must be awaited first!");
11538 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11539 return nativeResponseValue;
11541 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11543 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
11544 if(!isWasmInitialized) {
11545 throw new Error("initializeWasm() must be awaited first!");
11547 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11548 return nativeResponseValue;
11550 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
11552 export function COption_u16Z_some(o: number): number {
11553 if(!isWasmInitialized) {
11554 throw new Error("initializeWasm() must be awaited first!");
11556 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
11557 return nativeResponseValue;
11559 // struct LDKCOption_u16Z COption_u16Z_none(void);
11561 export function COption_u16Z_none(): number {
11562 if(!isWasmInitialized) {
11563 throw new Error("initializeWasm() must be awaited first!");
11565 const nativeResponseValue = wasm.TS_COption_u16Z_none();
11566 return nativeResponseValue;
11568 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
11570 export function COption_u16Z_free(_res: number): void {
11571 if(!isWasmInitialized) {
11572 throw new Error("initializeWasm() must be awaited first!");
11574 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
11575 // debug statements here
11577 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
11579 export function COption_u16Z_clone_ptr(arg: number): number {
11580 if(!isWasmInitialized) {
11581 throw new Error("initializeWasm() must be awaited first!");
11583 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
11584 return nativeResponseValue;
11586 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
11588 export function COption_u16Z_clone(orig: number): number {
11589 if(!isWasmInitialized) {
11590 throw new Error("initializeWasm() must be awaited first!");
11592 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
11593 return nativeResponseValue;
11595 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11597 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11598 if(!isWasmInitialized) {
11599 throw new Error("initializeWasm() must be awaited first!");
11601 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11602 // debug statements here
11604 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11606 export function CVec_APIErrorZ_free(_res: number): void {
11607 if(!isWasmInitialized) {
11608 throw new Error("initializeWasm() must be awaited first!");
11610 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11611 // debug statements here
11613 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11615 export function CResult__u832APIErrorZ_ok(o: number): number {
11616 if(!isWasmInitialized) {
11617 throw new Error("initializeWasm() must be awaited first!");
11619 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11620 return nativeResponseValue;
11622 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11624 export function CResult__u832APIErrorZ_err(e: number): number {
11625 if(!isWasmInitialized) {
11626 throw new Error("initializeWasm() must be awaited first!");
11628 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11629 return nativeResponseValue;
11631 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11633 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
11634 if(!isWasmInitialized) {
11635 throw new Error("initializeWasm() must be awaited first!");
11637 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11638 return nativeResponseValue;
11640 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11642 export function CResult__u832APIErrorZ_free(_res: number): void {
11643 if(!isWasmInitialized) {
11644 throw new Error("initializeWasm() must be awaited first!");
11646 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11647 // debug statements here
11649 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11651 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
11652 if(!isWasmInitialized) {
11653 throw new Error("initializeWasm() must be awaited first!");
11655 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11656 return nativeResponseValue;
11658 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11660 export function CResult__u832APIErrorZ_clone(orig: number): number {
11661 if(!isWasmInitialized) {
11662 throw new Error("initializeWasm() must be awaited first!");
11664 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
11665 return nativeResponseValue;
11667 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
11669 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
11670 if(!isWasmInitialized) {
11671 throw new Error("initializeWasm() must be awaited first!");
11673 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
11674 return nativeResponseValue;
11676 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11678 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
11679 if(!isWasmInitialized) {
11680 throw new Error("initializeWasm() must be awaited first!");
11682 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
11683 return nativeResponseValue;
11685 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
11687 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
11688 if(!isWasmInitialized) {
11689 throw new Error("initializeWasm() must be awaited first!");
11691 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
11692 return nativeResponseValue;
11694 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
11696 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
11697 if(!isWasmInitialized) {
11698 throw new Error("initializeWasm() must be awaited first!");
11700 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
11701 // debug statements here
11703 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
11705 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
11706 if(!isWasmInitialized) {
11707 throw new Error("initializeWasm() must be awaited first!");
11709 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
11710 return nativeResponseValue;
11712 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
11714 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
11715 if(!isWasmInitialized) {
11716 throw new Error("initializeWasm() must be awaited first!");
11718 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
11719 return nativeResponseValue;
11721 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
11723 export function CResult_NonePaymentSendFailureZ_ok(): number {
11724 if(!isWasmInitialized) {
11725 throw new Error("initializeWasm() must be awaited first!");
11727 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
11728 return nativeResponseValue;
11730 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11732 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
11733 if(!isWasmInitialized) {
11734 throw new Error("initializeWasm() must be awaited first!");
11736 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
11737 return nativeResponseValue;
11739 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
11741 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
11742 if(!isWasmInitialized) {
11743 throw new Error("initializeWasm() must be awaited first!");
11745 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
11746 return nativeResponseValue;
11748 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
11750 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
11751 if(!isWasmInitialized) {
11752 throw new Error("initializeWasm() must be awaited first!");
11754 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
11755 // debug statements here
11757 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
11759 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
11760 if(!isWasmInitialized) {
11761 throw new Error("initializeWasm() must be awaited first!");
11763 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
11764 return nativeResponseValue;
11766 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
11768 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
11769 if(!isWasmInitialized) {
11770 throw new Error("initializeWasm() must be awaited first!");
11772 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
11773 return nativeResponseValue;
11775 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
11777 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
11778 if(!isWasmInitialized) {
11779 throw new Error("initializeWasm() must be awaited first!");
11781 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
11782 return nativeResponseValue;
11784 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
11786 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
11787 if(!isWasmInitialized) {
11788 throw new Error("initializeWasm() must be awaited first!");
11790 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
11791 return nativeResponseValue;
11793 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11795 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
11796 if(!isWasmInitialized) {
11797 throw new Error("initializeWasm() must be awaited first!");
11799 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
11800 return nativeResponseValue;
11802 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
11804 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
11805 if(!isWasmInitialized) {
11806 throw new Error("initializeWasm() must be awaited first!");
11808 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
11809 // debug statements here
11811 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
11813 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
11814 if(!isWasmInitialized) {
11815 throw new Error("initializeWasm() must be awaited first!");
11817 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
11818 return nativeResponseValue;
11820 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11822 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
11823 if(!isWasmInitialized) {
11824 throw new Error("initializeWasm() must be awaited first!");
11826 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
11827 return nativeResponseValue;
11829 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
11831 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
11832 if(!isWasmInitialized) {
11833 throw new Error("initializeWasm() must be awaited first!");
11835 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
11836 return nativeResponseValue;
11838 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
11840 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
11841 if(!isWasmInitialized) {
11842 throw new Error("initializeWasm() must be awaited first!");
11844 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
11845 // debug statements here
11847 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
11849 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
11850 if(!isWasmInitialized) {
11851 throw new Error("initializeWasm() must be awaited first!");
11853 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
11854 return nativeResponseValue;
11856 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
11858 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
11859 if(!isWasmInitialized) {
11860 throw new Error("initializeWasm() must be awaited first!");
11862 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
11863 return nativeResponseValue;
11865 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
11867 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
11868 if(!isWasmInitialized) {
11869 throw new Error("initializeWasm() must be awaited first!");
11871 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
11872 return nativeResponseValue;
11874 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
11876 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
11877 if(!isWasmInitialized) {
11878 throw new Error("initializeWasm() must be awaited first!");
11880 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
11881 return nativeResponseValue;
11883 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11885 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
11886 if(!isWasmInitialized) {
11887 throw new Error("initializeWasm() must be awaited first!");
11889 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
11890 return nativeResponseValue;
11892 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11894 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
11895 if(!isWasmInitialized) {
11896 throw new Error("initializeWasm() must be awaited first!");
11898 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11899 // debug statements here
11901 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11903 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
11904 if(!isWasmInitialized) {
11905 throw new Error("initializeWasm() must be awaited first!");
11907 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11908 return nativeResponseValue;
11910 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11912 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
11913 if(!isWasmInitialized) {
11914 throw new Error("initializeWasm() must be awaited first!");
11916 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11917 return nativeResponseValue;
11919 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11921 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
11922 if(!isWasmInitialized) {
11923 throw new Error("initializeWasm() must be awaited first!");
11925 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11926 return nativeResponseValue;
11928 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11930 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
11931 if(!isWasmInitialized) {
11932 throw new Error("initializeWasm() must be awaited first!");
11934 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11935 // debug statements here
11937 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11939 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
11940 if(!isWasmInitialized) {
11941 throw new Error("initializeWasm() must be awaited first!");
11943 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11944 return nativeResponseValue;
11946 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11948 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
11949 if(!isWasmInitialized) {
11950 throw new Error("initializeWasm() must be awaited first!");
11952 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11953 return nativeResponseValue;
11955 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11957 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
11958 if(!isWasmInitialized) {
11959 throw new Error("initializeWasm() must be awaited first!");
11961 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11962 return nativeResponseValue;
11964 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11966 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
11967 if(!isWasmInitialized) {
11968 throw new Error("initializeWasm() must be awaited first!");
11970 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11971 return nativeResponseValue;
11973 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11975 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
11976 if(!isWasmInitialized) {
11977 throw new Error("initializeWasm() must be awaited first!");
11979 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11980 return nativeResponseValue;
11982 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
11984 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
11985 if(!isWasmInitialized) {
11986 throw new Error("initializeWasm() must be awaited first!");
11988 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
11989 // debug statements here
11991 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
11993 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
11994 if(!isWasmInitialized) {
11995 throw new Error("initializeWasm() must be awaited first!");
11997 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
11998 return nativeResponseValue;
12000 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
12002 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
12003 if(!isWasmInitialized) {
12004 throw new Error("initializeWasm() must be awaited first!");
12006 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
12007 return nativeResponseValue;
12009 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
12011 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
12012 if(!isWasmInitialized) {
12013 throw new Error("initializeWasm() must be awaited first!");
12015 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
12016 return nativeResponseValue;
12018 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
12020 export function CResult_PaymentSecretNoneZ_err(): number {
12021 if(!isWasmInitialized) {
12022 throw new Error("initializeWasm() must be awaited first!");
12024 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
12025 return nativeResponseValue;
12027 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
12029 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
12030 if(!isWasmInitialized) {
12031 throw new Error("initializeWasm() must be awaited first!");
12033 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
12034 return nativeResponseValue;
12036 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
12038 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
12039 if(!isWasmInitialized) {
12040 throw new Error("initializeWasm() must be awaited first!");
12042 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
12043 // debug statements here
12045 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
12047 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
12048 if(!isWasmInitialized) {
12049 throw new Error("initializeWasm() must be awaited first!");
12051 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
12052 return nativeResponseValue;
12054 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
12056 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
12057 if(!isWasmInitialized) {
12058 throw new Error("initializeWasm() must be awaited first!");
12060 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
12061 return nativeResponseValue;
12063 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12065 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
12066 if(!isWasmInitialized) {
12067 throw new Error("initializeWasm() must be awaited first!");
12069 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
12070 return nativeResponseValue;
12072 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
12074 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
12075 if(!isWasmInitialized) {
12076 throw new Error("initializeWasm() must be awaited first!");
12078 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
12079 return nativeResponseValue;
12081 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
12083 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
12084 if(!isWasmInitialized) {
12085 throw new Error("initializeWasm() must be awaited first!");
12087 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
12088 return nativeResponseValue;
12090 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
12092 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
12093 if(!isWasmInitialized) {
12094 throw new Error("initializeWasm() must be awaited first!");
12096 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
12097 // debug statements here
12099 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
12101 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
12102 if(!isWasmInitialized) {
12103 throw new Error("initializeWasm() must be awaited first!");
12105 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
12106 return nativeResponseValue;
12108 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
12110 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
12111 if(!isWasmInitialized) {
12112 throw new Error("initializeWasm() must be awaited first!");
12114 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
12115 return nativeResponseValue;
12117 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
12119 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
12120 if(!isWasmInitialized) {
12121 throw new Error("initializeWasm() must be awaited first!");
12123 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
12124 return nativeResponseValue;
12126 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
12128 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
12129 if(!isWasmInitialized) {
12130 throw new Error("initializeWasm() must be awaited first!");
12132 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
12133 return nativeResponseValue;
12135 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
12137 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
12138 if(!isWasmInitialized) {
12139 throw new Error("initializeWasm() must be awaited first!");
12141 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
12142 return nativeResponseValue;
12144 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
12146 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
12147 if(!isWasmInitialized) {
12148 throw new Error("initializeWasm() must be awaited first!");
12150 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
12151 // debug statements here
12153 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
12155 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
12156 if(!isWasmInitialized) {
12157 throw new Error("initializeWasm() must be awaited first!");
12159 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
12160 return nativeResponseValue;
12162 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
12164 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
12165 if(!isWasmInitialized) {
12166 throw new Error("initializeWasm() must be awaited first!");
12168 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
12169 return nativeResponseValue;
12171 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
12173 export function CVec_ChannelMonitorZ_free(_res: number): void {
12174 if(!isWasmInitialized) {
12175 throw new Error("initializeWasm() must be awaited first!");
12177 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
12178 // debug statements here
12180 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
12182 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
12183 if(!isWasmInitialized) {
12184 throw new Error("initializeWasm() must be awaited first!");
12186 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
12187 return nativeResponseValue;
12189 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
12191 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
12192 if(!isWasmInitialized) {
12193 throw new Error("initializeWasm() must be awaited first!");
12195 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
12196 // debug statements here
12198 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
12200 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
12201 if(!isWasmInitialized) {
12202 throw new Error("initializeWasm() must be awaited first!");
12204 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
12205 return nativeResponseValue;
12207 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
12209 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
12210 if(!isWasmInitialized) {
12211 throw new Error("initializeWasm() must be awaited first!");
12213 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
12214 return nativeResponseValue;
12216 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
12218 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
12219 if(!isWasmInitialized) {
12220 throw new Error("initializeWasm() must be awaited first!");
12222 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
12223 return nativeResponseValue;
12225 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
12227 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
12228 if(!isWasmInitialized) {
12229 throw new Error("initializeWasm() must be awaited first!");
12231 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
12232 // debug statements here
12234 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
12236 export function PaymentPurpose_free(this_ptr: number): void {
12237 if(!isWasmInitialized) {
12238 throw new Error("initializeWasm() must be awaited first!");
12240 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
12241 // debug statements here
12243 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
12245 export function PaymentPurpose_clone_ptr(arg: number): number {
12246 if(!isWasmInitialized) {
12247 throw new Error("initializeWasm() must be awaited first!");
12249 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
12250 return nativeResponseValue;
12252 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
12254 export function PaymentPurpose_clone(orig: number): number {
12255 if(!isWasmInitialized) {
12256 throw new Error("initializeWasm() must be awaited first!");
12258 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
12259 return nativeResponseValue;
12261 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
12263 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
12264 if(!isWasmInitialized) {
12265 throw new Error("initializeWasm() must be awaited first!");
12267 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
12268 return nativeResponseValue;
12270 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
12272 export function PaymentPurpose_spontaneous_payment(a: number): number {
12273 if(!isWasmInitialized) {
12274 throw new Error("initializeWasm() must be awaited first!");
12276 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
12277 return nativeResponseValue;
12279 // void ClosureReason_free(struct LDKClosureReason this_ptr);
12281 export function ClosureReason_free(this_ptr: number): void {
12282 if(!isWasmInitialized) {
12283 throw new Error("initializeWasm() must be awaited first!");
12285 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
12286 // debug statements here
12288 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
12290 export function ClosureReason_clone_ptr(arg: number): number {
12291 if(!isWasmInitialized) {
12292 throw new Error("initializeWasm() must be awaited first!");
12294 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
12295 return nativeResponseValue;
12297 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
12299 export function ClosureReason_clone(orig: number): number {
12300 if(!isWasmInitialized) {
12301 throw new Error("initializeWasm() must be awaited first!");
12303 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
12304 return nativeResponseValue;
12306 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
12308 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
12309 if(!isWasmInitialized) {
12310 throw new Error("initializeWasm() must be awaited first!");
12312 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
12313 return nativeResponseValue;
12315 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
12317 export function ClosureReason_holder_force_closed(): number {
12318 if(!isWasmInitialized) {
12319 throw new Error("initializeWasm() must be awaited first!");
12321 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
12322 return nativeResponseValue;
12324 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
12326 export function ClosureReason_cooperative_closure(): number {
12327 if(!isWasmInitialized) {
12328 throw new Error("initializeWasm() must be awaited first!");
12330 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
12331 return nativeResponseValue;
12333 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
12335 export function ClosureReason_commitment_tx_confirmed(): number {
12336 if(!isWasmInitialized) {
12337 throw new Error("initializeWasm() must be awaited first!");
12339 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
12340 return nativeResponseValue;
12342 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
12344 export function ClosureReason_funding_timed_out(): number {
12345 if(!isWasmInitialized) {
12346 throw new Error("initializeWasm() must be awaited first!");
12348 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
12349 return nativeResponseValue;
12351 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
12353 export function ClosureReason_processing_error(err: number): number {
12354 if(!isWasmInitialized) {
12355 throw new Error("initializeWasm() must be awaited first!");
12357 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
12358 return nativeResponseValue;
12360 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
12362 export function ClosureReason_disconnected_peer(): number {
12363 if(!isWasmInitialized) {
12364 throw new Error("initializeWasm() must be awaited first!");
12366 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
12367 return nativeResponseValue;
12369 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
12371 export function ClosureReason_outdated_channel_manager(): number {
12372 if(!isWasmInitialized) {
12373 throw new Error("initializeWasm() must be awaited first!");
12375 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
12376 return nativeResponseValue;
12378 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
12380 export function ClosureReason_write(obj: number): number {
12381 if(!isWasmInitialized) {
12382 throw new Error("initializeWasm() must be awaited first!");
12384 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
12385 return nativeResponseValue;
12387 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
12389 export function ClosureReason_read(ser: number): number {
12390 if(!isWasmInitialized) {
12391 throw new Error("initializeWasm() must be awaited first!");
12393 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
12394 return nativeResponseValue;
12396 // void Event_free(struct LDKEvent this_ptr);
12398 export function Event_free(this_ptr: number): void {
12399 if(!isWasmInitialized) {
12400 throw new Error("initializeWasm() must be awaited first!");
12402 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
12403 // debug statements here
12405 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
12407 export function Event_clone_ptr(arg: number): number {
12408 if(!isWasmInitialized) {
12409 throw new Error("initializeWasm() must be awaited first!");
12411 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
12412 return nativeResponseValue;
12414 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
12416 export function Event_clone(orig: number): number {
12417 if(!isWasmInitialized) {
12418 throw new Error("initializeWasm() must be awaited first!");
12420 const nativeResponseValue = wasm.TS_Event_clone(orig);
12421 return nativeResponseValue;
12423 // 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);
12425 export function Event_funding_generation_ready(temporary_channel_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): number {
12426 if(!isWasmInitialized) {
12427 throw new Error("initializeWasm() must be awaited first!");
12429 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
12430 return nativeResponseValue;
12432 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
12434 export function Event_payment_received(payment_hash: number, amt: bigint, purpose: number): number {
12435 if(!isWasmInitialized) {
12436 throw new Error("initializeWasm() must be awaited first!");
12438 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amt, purpose);
12439 return nativeResponseValue;
12441 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
12443 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
12444 if(!isWasmInitialized) {
12445 throw new Error("initializeWasm() must be awaited first!");
12447 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
12448 return nativeResponseValue;
12450 // 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);
12452 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 {
12453 if(!isWasmInitialized) {
12454 throw new Error("initializeWasm() must be awaited first!");
12456 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);
12457 return nativeResponseValue;
12459 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
12461 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
12462 if(!isWasmInitialized) {
12463 throw new Error("initializeWasm() must be awaited first!");
12465 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
12466 return nativeResponseValue;
12468 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
12470 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
12471 if(!isWasmInitialized) {
12472 throw new Error("initializeWasm() must be awaited first!");
12474 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
12475 return nativeResponseValue;
12477 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
12479 export function Event_spendable_outputs(outputs: number): number {
12480 if(!isWasmInitialized) {
12481 throw new Error("initializeWasm() must be awaited first!");
12483 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
12484 return nativeResponseValue;
12486 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
12488 export function Event_payment_forwarded(fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
12489 if(!isWasmInitialized) {
12490 throw new Error("initializeWasm() must be awaited first!");
12492 const nativeResponseValue = wasm.TS_Event_payment_forwarded(fee_earned_msat, claim_from_onchain_tx);
12493 return nativeResponseValue;
12495 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
12497 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
12498 if(!isWasmInitialized) {
12499 throw new Error("initializeWasm() must be awaited first!");
12501 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
12502 return nativeResponseValue;
12504 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
12506 export function Event_discard_funding(channel_id: number, transaction: number): number {
12507 if(!isWasmInitialized) {
12508 throw new Error("initializeWasm() must be awaited first!");
12510 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
12511 return nativeResponseValue;
12513 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
12515 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
12516 if(!isWasmInitialized) {
12517 throw new Error("initializeWasm() must be awaited first!");
12519 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
12520 return nativeResponseValue;
12522 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
12524 export function Event_write(obj: number): number {
12525 if(!isWasmInitialized) {
12526 throw new Error("initializeWasm() must be awaited first!");
12528 const nativeResponseValue = wasm.TS_Event_write(obj);
12529 return nativeResponseValue;
12531 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
12533 export function Event_read(ser: number): number {
12534 if(!isWasmInitialized) {
12535 throw new Error("initializeWasm() must be awaited first!");
12537 const nativeResponseValue = wasm.TS_Event_read(ser);
12538 return nativeResponseValue;
12540 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
12542 export function MessageSendEvent_free(this_ptr: number): void {
12543 if(!isWasmInitialized) {
12544 throw new Error("initializeWasm() must be awaited first!");
12546 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
12547 // debug statements here
12549 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
12551 export function MessageSendEvent_clone_ptr(arg: number): number {
12552 if(!isWasmInitialized) {
12553 throw new Error("initializeWasm() must be awaited first!");
12555 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
12556 return nativeResponseValue;
12558 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
12560 export function MessageSendEvent_clone(orig: number): number {
12561 if(!isWasmInitialized) {
12562 throw new Error("initializeWasm() must be awaited first!");
12564 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
12565 return nativeResponseValue;
12567 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
12569 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
12570 if(!isWasmInitialized) {
12571 throw new Error("initializeWasm() must be awaited first!");
12573 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
12574 return nativeResponseValue;
12576 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
12578 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
12579 if(!isWasmInitialized) {
12580 throw new Error("initializeWasm() must be awaited first!");
12582 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
12583 return nativeResponseValue;
12585 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
12587 export function MessageSendEvent_send_funding_created(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_funding_created(node_id, msg);
12592 return nativeResponseValue;
12594 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
12596 export function MessageSendEvent_send_funding_signed(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_funding_signed(node_id, msg);
12601 return nativeResponseValue;
12603 // struct LDKMessageSendEvent MessageSendEvent_send_funding_locked(struct LDKPublicKey node_id, struct LDKFundingLocked msg);
12605 export function MessageSendEvent_send_funding_locked(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_locked(node_id, msg);
12610 return nativeResponseValue;
12612 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
12614 export function MessageSendEvent_send_announcement_signatures(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_announcement_signatures(node_id, msg);
12619 return nativeResponseValue;
12621 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
12623 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
12624 if(!isWasmInitialized) {
12625 throw new Error("initializeWasm() must be awaited first!");
12627 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
12628 return nativeResponseValue;
12630 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
12632 export function MessageSendEvent_send_revoke_and_ack(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_revoke_and_ack(node_id, msg);
12637 return nativeResponseValue;
12639 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
12641 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
12642 if(!isWasmInitialized) {
12643 throw new Error("initializeWasm() must be awaited first!");
12645 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
12646 return nativeResponseValue;
12648 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
12650 export function MessageSendEvent_send_shutdown(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_shutdown(node_id, msg);
12655 return nativeResponseValue;
12657 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
12659 export function MessageSendEvent_send_channel_reestablish(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_channel_reestablish(node_id, msg);
12664 return nativeResponseValue;
12666 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
12668 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
12669 if(!isWasmInitialized) {
12670 throw new Error("initializeWasm() must be awaited first!");
12672 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
12673 return nativeResponseValue;
12675 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
12677 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
12678 if(!isWasmInitialized) {
12679 throw new Error("initializeWasm() must be awaited first!");
12681 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
12682 return nativeResponseValue;
12684 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
12686 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
12687 if(!isWasmInitialized) {
12688 throw new Error("initializeWasm() must be awaited first!");
12690 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
12691 return nativeResponseValue;
12693 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
12695 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
12696 if(!isWasmInitialized) {
12697 throw new Error("initializeWasm() must be awaited first!");
12699 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
12700 return nativeResponseValue;
12702 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
12704 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
12705 if(!isWasmInitialized) {
12706 throw new Error("initializeWasm() must be awaited first!");
12708 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
12709 return nativeResponseValue;
12711 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
12713 export function MessageSendEvent_send_channel_range_query(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_range_query(node_id, msg);
12718 return nativeResponseValue;
12720 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
12722 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
12723 if(!isWasmInitialized) {
12724 throw new Error("initializeWasm() must be awaited first!");
12726 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
12727 return nativeResponseValue;
12729 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
12731 export function MessageSendEvent_send_reply_channel_range(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_reply_channel_range(node_id, msg);
12736 return nativeResponseValue;
12738 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
12740 export function MessageSendEventsProvider_free(this_ptr: number): void {
12741 if(!isWasmInitialized) {
12742 throw new Error("initializeWasm() must be awaited first!");
12744 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
12745 // debug statements here
12747 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
12749 export function EventsProvider_free(this_ptr: number): void {
12750 if(!isWasmInitialized) {
12751 throw new Error("initializeWasm() must be awaited first!");
12753 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
12754 // debug statements here
12756 // void EventHandler_free(struct LDKEventHandler this_ptr);
12758 export function EventHandler_free(this_ptr: number): void {
12759 if(!isWasmInitialized) {
12760 throw new Error("initializeWasm() must be awaited first!");
12762 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
12763 // debug statements here
12765 // void APIError_free(struct LDKAPIError this_ptr);
12767 export function APIError_free(this_ptr: number): void {
12768 if(!isWasmInitialized) {
12769 throw new Error("initializeWasm() must be awaited first!");
12771 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
12772 // debug statements here
12774 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
12776 export function APIError_clone_ptr(arg: number): number {
12777 if(!isWasmInitialized) {
12778 throw new Error("initializeWasm() must be awaited first!");
12780 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
12781 return nativeResponseValue;
12783 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
12785 export function APIError_clone(orig: number): number {
12786 if(!isWasmInitialized) {
12787 throw new Error("initializeWasm() must be awaited first!");
12789 const nativeResponseValue = wasm.TS_APIError_clone(orig);
12790 return nativeResponseValue;
12792 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
12794 export function APIError_apimisuse_error(err: number): number {
12795 if(!isWasmInitialized) {
12796 throw new Error("initializeWasm() must be awaited first!");
12798 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
12799 return nativeResponseValue;
12801 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
12803 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
12804 if(!isWasmInitialized) {
12805 throw new Error("initializeWasm() must be awaited first!");
12807 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
12808 return nativeResponseValue;
12810 // struct LDKAPIError APIError_route_error(struct LDKStr err);
12812 export function APIError_route_error(err: number): number {
12813 if(!isWasmInitialized) {
12814 throw new Error("initializeWasm() must be awaited first!");
12816 const nativeResponseValue = wasm.TS_APIError_route_error(err);
12817 return nativeResponseValue;
12819 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
12821 export function APIError_channel_unavailable(err: number): number {
12822 if(!isWasmInitialized) {
12823 throw new Error("initializeWasm() must be awaited first!");
12825 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
12826 return nativeResponseValue;
12828 // struct LDKAPIError APIError_monitor_update_failed(void);
12830 export function APIError_monitor_update_failed(): number {
12831 if(!isWasmInitialized) {
12832 throw new Error("initializeWasm() must be awaited first!");
12834 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
12835 return nativeResponseValue;
12837 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
12839 export function APIError_incompatible_shutdown_script(script: number): number {
12840 if(!isWasmInitialized) {
12841 throw new Error("initializeWasm() must be awaited first!");
12843 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
12844 return nativeResponseValue;
12846 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
12848 export function sign(msg: number, sk: number): number {
12849 if(!isWasmInitialized) {
12850 throw new Error("initializeWasm() must be awaited first!");
12852 const nativeResponseValue = wasm.TS_sign(msg, sk);
12853 return nativeResponseValue;
12855 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
12857 export function recover_pk(msg: number, sig: number): number {
12858 if(!isWasmInitialized) {
12859 throw new Error("initializeWasm() must be awaited first!");
12861 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
12862 return nativeResponseValue;
12864 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
12866 export function verify(msg: number, sig: number, pk: number): boolean {
12867 if(!isWasmInitialized) {
12868 throw new Error("initializeWasm() must be awaited first!");
12870 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
12871 return nativeResponseValue;
12873 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
12875 export function Level_clone(orig: number): Level {
12876 if(!isWasmInitialized) {
12877 throw new Error("initializeWasm() must be awaited first!");
12879 const nativeResponseValue = wasm.TS_Level_clone(orig);
12880 return nativeResponseValue;
12882 // enum LDKLevel Level_gossip(void);
12884 export function Level_gossip(): Level {
12885 if(!isWasmInitialized) {
12886 throw new Error("initializeWasm() must be awaited first!");
12888 const nativeResponseValue = wasm.TS_Level_gossip();
12889 return nativeResponseValue;
12891 // enum LDKLevel Level_trace(void);
12893 export function Level_trace(): Level {
12894 if(!isWasmInitialized) {
12895 throw new Error("initializeWasm() must be awaited first!");
12897 const nativeResponseValue = wasm.TS_Level_trace();
12898 return nativeResponseValue;
12900 // enum LDKLevel Level_debug(void);
12902 export function Level_debug(): Level {
12903 if(!isWasmInitialized) {
12904 throw new Error("initializeWasm() must be awaited first!");
12906 const nativeResponseValue = wasm.TS_Level_debug();
12907 return nativeResponseValue;
12909 // enum LDKLevel Level_info(void);
12911 export function Level_info(): Level {
12912 if(!isWasmInitialized) {
12913 throw new Error("initializeWasm() must be awaited first!");
12915 const nativeResponseValue = wasm.TS_Level_info();
12916 return nativeResponseValue;
12918 // enum LDKLevel Level_warn(void);
12920 export function Level_warn(): Level {
12921 if(!isWasmInitialized) {
12922 throw new Error("initializeWasm() must be awaited first!");
12924 const nativeResponseValue = wasm.TS_Level_warn();
12925 return nativeResponseValue;
12927 // enum LDKLevel Level_error(void);
12929 export function Level_error(): Level {
12930 if(!isWasmInitialized) {
12931 throw new Error("initializeWasm() must be awaited first!");
12933 const nativeResponseValue = wasm.TS_Level_error();
12934 return nativeResponseValue;
12936 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
12938 export function Level_eq(a: number, b: number): boolean {
12939 if(!isWasmInitialized) {
12940 throw new Error("initializeWasm() must be awaited first!");
12942 const nativeResponseValue = wasm.TS_Level_eq(a, b);
12943 return nativeResponseValue;
12945 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
12947 export function Level_hash(o: number): bigint {
12948 if(!isWasmInitialized) {
12949 throw new Error("initializeWasm() must be awaited first!");
12951 const nativeResponseValue = wasm.TS_Level_hash(o);
12952 return nativeResponseValue;
12954 // MUST_USE_RES enum LDKLevel Level_max(void);
12956 export function Level_max(): Level {
12957 if(!isWasmInitialized) {
12958 throw new Error("initializeWasm() must be awaited first!");
12960 const nativeResponseValue = wasm.TS_Level_max();
12961 return nativeResponseValue;
12963 // void Record_free(struct LDKRecord this_obj);
12965 export function Record_free(this_obj: number): void {
12966 if(!isWasmInitialized) {
12967 throw new Error("initializeWasm() must be awaited first!");
12969 const nativeResponseValue = wasm.TS_Record_free(this_obj);
12970 // debug statements here
12972 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
12974 export function Record_get_level(this_ptr: number): Level {
12975 if(!isWasmInitialized) {
12976 throw new Error("initializeWasm() must be awaited first!");
12978 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
12979 return nativeResponseValue;
12981 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
12983 export function Record_set_level(this_ptr: number, val: Level): void {
12984 if(!isWasmInitialized) {
12985 throw new Error("initializeWasm() must be awaited first!");
12987 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
12988 // debug statements here
12990 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
12992 export function Record_get_args(this_ptr: number): number {
12993 if(!isWasmInitialized) {
12994 throw new Error("initializeWasm() must be awaited first!");
12996 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
12997 return nativeResponseValue;
12999 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
13001 export function Record_set_args(this_ptr: number, val: number): void {
13002 if(!isWasmInitialized) {
13003 throw new Error("initializeWasm() must be awaited first!");
13005 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
13006 // debug statements here
13008 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
13010 export function Record_get_module_path(this_ptr: number): number {
13011 if(!isWasmInitialized) {
13012 throw new Error("initializeWasm() must be awaited first!");
13014 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
13015 return nativeResponseValue;
13017 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
13019 export function Record_set_module_path(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_module_path(this_ptr, val);
13024 // debug statements here
13026 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
13028 export function Record_get_file(this_ptr: number): number {
13029 if(!isWasmInitialized) {
13030 throw new Error("initializeWasm() must be awaited first!");
13032 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
13033 return nativeResponseValue;
13035 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
13037 export function Record_set_file(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_file(this_ptr, val);
13042 // debug statements here
13044 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
13046 export function Record_get_line(this_ptr: number): number {
13047 if(!isWasmInitialized) {
13048 throw new Error("initializeWasm() must be awaited first!");
13050 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
13051 return nativeResponseValue;
13053 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
13055 export function Record_set_line(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_line(this_ptr, val);
13060 // debug statements here
13062 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
13064 export function Record_clone_ptr(arg: number): number {
13065 if(!isWasmInitialized) {
13066 throw new Error("initializeWasm() must be awaited first!");
13068 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
13069 return nativeResponseValue;
13071 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
13073 export function Record_clone(orig: number): number {
13074 if(!isWasmInitialized) {
13075 throw new Error("initializeWasm() must be awaited first!");
13077 const nativeResponseValue = wasm.TS_Record_clone(orig);
13078 return nativeResponseValue;
13080 // void Logger_free(struct LDKLogger this_ptr);
13082 export function Logger_free(this_ptr: number): void {
13083 if(!isWasmInitialized) {
13084 throw new Error("initializeWasm() must be awaited first!");
13086 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
13087 // debug statements here
13089 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
13091 export function ChannelHandshakeConfig_free(this_obj: number): void {
13092 if(!isWasmInitialized) {
13093 throw new Error("initializeWasm() must be awaited first!");
13095 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
13096 // debug statements here
13098 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
13100 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
13101 if(!isWasmInitialized) {
13102 throw new Error("initializeWasm() must be awaited first!");
13104 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
13105 return nativeResponseValue;
13107 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
13109 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
13110 if(!isWasmInitialized) {
13111 throw new Error("initializeWasm() must be awaited first!");
13113 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
13114 // debug statements here
13116 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
13118 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
13119 if(!isWasmInitialized) {
13120 throw new Error("initializeWasm() must be awaited first!");
13122 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
13123 return nativeResponseValue;
13125 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
13127 export function ChannelHandshakeConfig_set_our_to_self_delay(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_our_to_self_delay(this_ptr, val);
13132 // debug statements here
13134 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
13136 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
13137 if(!isWasmInitialized) {
13138 throw new Error("initializeWasm() must be awaited first!");
13140 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
13141 return nativeResponseValue;
13143 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
13145 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
13146 if(!isWasmInitialized) {
13147 throw new Error("initializeWasm() must be awaited first!");
13149 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
13150 // debug statements here
13152 // 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);
13154 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint): number {
13155 if(!isWasmInitialized) {
13156 throw new Error("initializeWasm() must be awaited first!");
13158 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
13159 return nativeResponseValue;
13161 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
13163 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
13164 if(!isWasmInitialized) {
13165 throw new Error("initializeWasm() must be awaited first!");
13167 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
13168 return nativeResponseValue;
13170 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
13172 export function ChannelHandshakeConfig_clone(orig: number): number {
13173 if(!isWasmInitialized) {
13174 throw new Error("initializeWasm() must be awaited first!");
13176 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
13177 return nativeResponseValue;
13179 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
13181 export function ChannelHandshakeConfig_default(): number {
13182 if(!isWasmInitialized) {
13183 throw new Error("initializeWasm() must be awaited first!");
13185 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
13186 return nativeResponseValue;
13188 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
13190 export function ChannelHandshakeLimits_free(this_obj: number): void {
13191 if(!isWasmInitialized) {
13192 throw new Error("initializeWasm() must be awaited first!");
13194 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
13195 // debug statements here
13197 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13199 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
13200 if(!isWasmInitialized) {
13201 throw new Error("initializeWasm() must be awaited first!");
13203 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
13204 return nativeResponseValue;
13206 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13208 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
13209 if(!isWasmInitialized) {
13210 throw new Error("initializeWasm() must be awaited first!");
13212 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
13213 // debug statements here
13215 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13217 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
13218 if(!isWasmInitialized) {
13219 throw new Error("initializeWasm() must be awaited first!");
13221 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
13222 return nativeResponseValue;
13224 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13226 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(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_max_htlc_minimum_msat(this_ptr, val);
13231 // debug statements here
13233 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13235 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
13236 if(!isWasmInitialized) {
13237 throw new Error("initializeWasm() must be awaited first!");
13239 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
13240 return nativeResponseValue;
13242 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13244 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_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_min_max_htlc_value_in_flight_msat(this_ptr, val);
13249 // debug statements here
13251 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13253 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
13254 if(!isWasmInitialized) {
13255 throw new Error("initializeWasm() must be awaited first!");
13257 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
13258 return nativeResponseValue;
13260 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
13262 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(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_max_channel_reserve_satoshis(this_ptr, val);
13267 // debug statements here
13269 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13271 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
13272 if(!isWasmInitialized) {
13273 throw new Error("initializeWasm() must be awaited first!");
13275 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
13276 return nativeResponseValue;
13278 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
13280 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
13281 if(!isWasmInitialized) {
13282 throw new Error("initializeWasm() must be awaited first!");
13284 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
13285 // debug statements here
13287 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13289 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
13290 if(!isWasmInitialized) {
13291 throw new Error("initializeWasm() must be awaited first!");
13293 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
13294 return nativeResponseValue;
13296 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
13298 export function ChannelHandshakeLimits_set_max_minimum_depth(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_max_minimum_depth(this_ptr, val);
13303 // debug statements here
13305 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13307 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
13308 if(!isWasmInitialized) {
13309 throw new Error("initializeWasm() must be awaited first!");
13311 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
13312 return nativeResponseValue;
13314 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
13316 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
13317 if(!isWasmInitialized) {
13318 throw new Error("initializeWasm() must be awaited first!");
13320 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
13321 // debug statements here
13323 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
13325 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
13326 if(!isWasmInitialized) {
13327 throw new Error("initializeWasm() must be awaited first!");
13329 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
13330 return nativeResponseValue;
13332 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
13334 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
13335 if(!isWasmInitialized) {
13336 throw new Error("initializeWasm() must be awaited first!");
13338 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
13339 // debug statements here
13341 // 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);
13343 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 {
13344 if(!isWasmInitialized) {
13345 throw new Error("initializeWasm() must be awaited first!");
13347 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);
13348 return nativeResponseValue;
13350 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
13352 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
13353 if(!isWasmInitialized) {
13354 throw new Error("initializeWasm() must be awaited first!");
13356 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
13357 return nativeResponseValue;
13359 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
13361 export function ChannelHandshakeLimits_clone(orig: number): number {
13362 if(!isWasmInitialized) {
13363 throw new Error("initializeWasm() must be awaited first!");
13365 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
13366 return nativeResponseValue;
13368 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
13370 export function ChannelHandshakeLimits_default(): number {
13371 if(!isWasmInitialized) {
13372 throw new Error("initializeWasm() must be awaited first!");
13374 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
13375 return nativeResponseValue;
13377 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
13379 export function ChannelConfig_free(this_obj: number): void {
13380 if(!isWasmInitialized) {
13381 throw new Error("initializeWasm() must be awaited first!");
13383 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
13384 // debug statements here
13386 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13388 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
13389 if(!isWasmInitialized) {
13390 throw new Error("initializeWasm() must be awaited first!");
13392 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
13393 return nativeResponseValue;
13395 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
13397 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
13398 if(!isWasmInitialized) {
13399 throw new Error("initializeWasm() must be awaited first!");
13401 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
13402 // debug statements here
13404 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13406 export function ChannelConfig_get_forwarding_fee_base_msat(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_base_msat(this_ptr);
13411 return nativeResponseValue;
13413 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
13415 export function ChannelConfig_set_forwarding_fee_base_msat(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_base_msat(this_ptr, val);
13420 // debug statements here
13422 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13424 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
13425 if(!isWasmInitialized) {
13426 throw new Error("initializeWasm() must be awaited first!");
13428 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
13429 return nativeResponseValue;
13431 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
13433 export function ChannelConfig_set_cltv_expiry_delta(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_cltv_expiry_delta(this_ptr, val);
13438 // debug statements here
13440 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13442 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
13443 if(!isWasmInitialized) {
13444 throw new Error("initializeWasm() must be awaited first!");
13446 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
13447 return nativeResponseValue;
13449 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
13451 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
13452 if(!isWasmInitialized) {
13453 throw new Error("initializeWasm() must be awaited first!");
13455 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
13456 // debug statements here
13458 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13460 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
13461 if(!isWasmInitialized) {
13462 throw new Error("initializeWasm() must be awaited first!");
13464 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
13465 return nativeResponseValue;
13467 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
13469 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(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_commit_upfront_shutdown_pubkey(this_ptr, val);
13474 // debug statements here
13476 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13478 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
13479 if(!isWasmInitialized) {
13480 throw new Error("initializeWasm() must be awaited first!");
13482 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
13483 return nativeResponseValue;
13485 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
13487 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
13488 if(!isWasmInitialized) {
13489 throw new Error("initializeWasm() must be awaited first!");
13491 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
13492 // debug statements here
13494 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
13496 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
13497 if(!isWasmInitialized) {
13498 throw new Error("initializeWasm() must be awaited first!");
13500 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
13501 return nativeResponseValue;
13503 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
13505 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(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_force_close_avoidance_max_fee_satoshis(this_ptr, val);
13510 // debug statements here
13512 // 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);
13514 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 {
13515 if(!isWasmInitialized) {
13516 throw new Error("initializeWasm() must be awaited first!");
13518 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);
13519 return nativeResponseValue;
13521 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
13523 export function ChannelConfig_clone_ptr(arg: number): number {
13524 if(!isWasmInitialized) {
13525 throw new Error("initializeWasm() must be awaited first!");
13527 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
13528 return nativeResponseValue;
13530 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
13532 export function ChannelConfig_clone(orig: number): number {
13533 if(!isWasmInitialized) {
13534 throw new Error("initializeWasm() must be awaited first!");
13536 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
13537 return nativeResponseValue;
13539 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
13541 export function ChannelConfig_default(): number {
13542 if(!isWasmInitialized) {
13543 throw new Error("initializeWasm() must be awaited first!");
13545 const nativeResponseValue = wasm.TS_ChannelConfig_default();
13546 return nativeResponseValue;
13548 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
13550 export function ChannelConfig_write(obj: number): number {
13551 if(!isWasmInitialized) {
13552 throw new Error("initializeWasm() must be awaited first!");
13554 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
13555 return nativeResponseValue;
13557 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
13559 export function ChannelConfig_read(ser: number): number {
13560 if(!isWasmInitialized) {
13561 throw new Error("initializeWasm() must be awaited first!");
13563 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
13564 return nativeResponseValue;
13566 // void UserConfig_free(struct LDKUserConfig this_obj);
13568 export function UserConfig_free(this_obj: number): void {
13569 if(!isWasmInitialized) {
13570 throw new Error("initializeWasm() must be awaited first!");
13572 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
13573 // debug statements here
13575 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13577 export function UserConfig_get_own_channel_config(this_ptr: number): number {
13578 if(!isWasmInitialized) {
13579 throw new Error("initializeWasm() must be awaited first!");
13581 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
13582 return nativeResponseValue;
13584 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
13586 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
13587 if(!isWasmInitialized) {
13588 throw new Error("initializeWasm() must be awaited first!");
13590 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
13591 // debug statements here
13593 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13595 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
13596 if(!isWasmInitialized) {
13597 throw new Error("initializeWasm() must be awaited first!");
13599 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
13600 return nativeResponseValue;
13602 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
13604 export function UserConfig_set_peer_channel_config_limits(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_peer_channel_config_limits(this_ptr, val);
13609 // debug statements here
13611 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13613 export function UserConfig_get_channel_options(this_ptr: number): number {
13614 if(!isWasmInitialized) {
13615 throw new Error("initializeWasm() must be awaited first!");
13617 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
13618 return nativeResponseValue;
13620 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
13622 export function UserConfig_set_channel_options(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_channel_options(this_ptr, val);
13627 // debug statements here
13629 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13631 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
13632 if(!isWasmInitialized) {
13633 throw new Error("initializeWasm() must be awaited first!");
13635 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
13636 return nativeResponseValue;
13638 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
13640 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
13641 if(!isWasmInitialized) {
13642 throw new Error("initializeWasm() must be awaited first!");
13644 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
13645 // debug statements here
13647 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
13649 export function UserConfig_get_accept_inbound_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_inbound_channels(this_ptr);
13654 return nativeResponseValue;
13656 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
13658 export function UserConfig_set_accept_inbound_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_inbound_channels(this_ptr, val);
13663 // debug statements here
13665 // 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);
13667 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 {
13668 if(!isWasmInitialized) {
13669 throw new Error("initializeWasm() must be awaited first!");
13671 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);
13672 return nativeResponseValue;
13674 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
13676 export function UserConfig_clone_ptr(arg: number): number {
13677 if(!isWasmInitialized) {
13678 throw new Error("initializeWasm() must be awaited first!");
13680 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
13681 return nativeResponseValue;
13683 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
13685 export function UserConfig_clone(orig: number): number {
13686 if(!isWasmInitialized) {
13687 throw new Error("initializeWasm() must be awaited first!");
13689 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
13690 return nativeResponseValue;
13692 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
13694 export function UserConfig_default(): number {
13695 if(!isWasmInitialized) {
13696 throw new Error("initializeWasm() must be awaited first!");
13698 const nativeResponseValue = wasm.TS_UserConfig_default();
13699 return nativeResponseValue;
13701 // void BestBlock_free(struct LDKBestBlock this_obj);
13703 export function BestBlock_free(this_obj: number): void {
13704 if(!isWasmInitialized) {
13705 throw new Error("initializeWasm() must be awaited first!");
13707 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
13708 // debug statements here
13710 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
13712 export function BestBlock_clone_ptr(arg: number): number {
13713 if(!isWasmInitialized) {
13714 throw new Error("initializeWasm() must be awaited first!");
13716 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
13717 return nativeResponseValue;
13719 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
13721 export function BestBlock_clone(orig: number): number {
13722 if(!isWasmInitialized) {
13723 throw new Error("initializeWasm() must be awaited first!");
13725 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
13726 return nativeResponseValue;
13728 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
13730 export function BestBlock_from_genesis(network: Network): number {
13731 if(!isWasmInitialized) {
13732 throw new Error("initializeWasm() must be awaited first!");
13734 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
13735 return nativeResponseValue;
13737 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
13739 export function BestBlock_new(block_hash: number, height: number): number {
13740 if(!isWasmInitialized) {
13741 throw new Error("initializeWasm() must be awaited first!");
13743 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
13744 return nativeResponseValue;
13746 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
13748 export function BestBlock_block_hash(this_arg: number): number {
13749 if(!isWasmInitialized) {
13750 throw new Error("initializeWasm() must be awaited first!");
13752 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
13753 return nativeResponseValue;
13755 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
13757 export function BestBlock_height(this_arg: number): number {
13758 if(!isWasmInitialized) {
13759 throw new Error("initializeWasm() must be awaited first!");
13761 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
13762 return nativeResponseValue;
13764 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
13766 export function AccessError_clone(orig: number): AccessError {
13767 if(!isWasmInitialized) {
13768 throw new Error("initializeWasm() must be awaited first!");
13770 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
13771 return nativeResponseValue;
13773 // enum LDKAccessError AccessError_unknown_chain(void);
13775 export function AccessError_unknown_chain(): AccessError {
13776 if(!isWasmInitialized) {
13777 throw new Error("initializeWasm() must be awaited first!");
13779 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
13780 return nativeResponseValue;
13782 // enum LDKAccessError AccessError_unknown_tx(void);
13784 export function AccessError_unknown_tx(): AccessError {
13785 if(!isWasmInitialized) {
13786 throw new Error("initializeWasm() must be awaited first!");
13788 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
13789 return nativeResponseValue;
13791 // void Access_free(struct LDKAccess this_ptr);
13793 export function Access_free(this_ptr: number): void {
13794 if(!isWasmInitialized) {
13795 throw new Error("initializeWasm() must be awaited first!");
13797 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
13798 // debug statements here
13800 // void Listen_free(struct LDKListen this_ptr);
13802 export function Listen_free(this_ptr: number): void {
13803 if(!isWasmInitialized) {
13804 throw new Error("initializeWasm() must be awaited first!");
13806 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
13807 // debug statements here
13809 // void Confirm_free(struct LDKConfirm this_ptr);
13811 export function Confirm_free(this_ptr: number): void {
13812 if(!isWasmInitialized) {
13813 throw new Error("initializeWasm() must be awaited first!");
13815 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
13816 // debug statements here
13818 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
13820 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
13821 if(!isWasmInitialized) {
13822 throw new Error("initializeWasm() must be awaited first!");
13824 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
13825 return nativeResponseValue;
13827 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
13829 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
13830 if(!isWasmInitialized) {
13831 throw new Error("initializeWasm() must be awaited first!");
13833 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
13834 return nativeResponseValue;
13836 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
13838 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
13839 if(!isWasmInitialized) {
13840 throw new Error("initializeWasm() must be awaited first!");
13842 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
13843 return nativeResponseValue;
13845 // void Watch_free(struct LDKWatch this_ptr);
13847 export function Watch_free(this_ptr: number): void {
13848 if(!isWasmInitialized) {
13849 throw new Error("initializeWasm() must be awaited first!");
13851 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
13852 // debug statements here
13854 // void Filter_free(struct LDKFilter this_ptr);
13856 export function Filter_free(this_ptr: number): void {
13857 if(!isWasmInitialized) {
13858 throw new Error("initializeWasm() must be awaited first!");
13860 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
13861 // debug statements here
13863 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
13865 export function WatchedOutput_free(this_obj: number): void {
13866 if(!isWasmInitialized) {
13867 throw new Error("initializeWasm() must be awaited first!");
13869 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
13870 // debug statements here
13872 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
13874 export function WatchedOutput_get_block_hash(this_ptr: number): number {
13875 if(!isWasmInitialized) {
13876 throw new Error("initializeWasm() must be awaited first!");
13878 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
13879 return nativeResponseValue;
13881 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
13883 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
13884 if(!isWasmInitialized) {
13885 throw new Error("initializeWasm() must be awaited first!");
13887 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
13888 // debug statements here
13890 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
13892 export function WatchedOutput_get_outpoint(this_ptr: number): number {
13893 if(!isWasmInitialized) {
13894 throw new Error("initializeWasm() must be awaited first!");
13896 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
13897 return nativeResponseValue;
13899 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
13901 export function WatchedOutput_set_outpoint(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_outpoint(this_ptr, val);
13906 // debug statements here
13908 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
13910 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
13911 if(!isWasmInitialized) {
13912 throw new Error("initializeWasm() must be awaited first!");
13914 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
13915 return nativeResponseValue;
13917 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
13919 export function WatchedOutput_set_script_pubkey(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_script_pubkey(this_ptr, val);
13924 // debug statements here
13926 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
13928 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
13929 if(!isWasmInitialized) {
13930 throw new Error("initializeWasm() must be awaited first!");
13932 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
13933 return nativeResponseValue;
13935 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
13937 export function WatchedOutput_clone_ptr(arg: number): number {
13938 if(!isWasmInitialized) {
13939 throw new Error("initializeWasm() must be awaited first!");
13941 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
13942 return nativeResponseValue;
13944 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
13946 export function WatchedOutput_clone(orig: number): number {
13947 if(!isWasmInitialized) {
13948 throw new Error("initializeWasm() must be awaited first!");
13950 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
13951 return nativeResponseValue;
13953 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
13955 export function WatchedOutput_hash(o: number): bigint {
13956 if(!isWasmInitialized) {
13957 throw new Error("initializeWasm() must be awaited first!");
13959 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
13960 return nativeResponseValue;
13962 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
13964 export function BroadcasterInterface_free(this_ptr: number): void {
13965 if(!isWasmInitialized) {
13966 throw new Error("initializeWasm() must be awaited first!");
13968 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
13969 // debug statements here
13971 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
13973 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
13974 if(!isWasmInitialized) {
13975 throw new Error("initializeWasm() must be awaited first!");
13977 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
13978 return nativeResponseValue;
13980 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
13982 export function ConfirmationTarget_background(): ConfirmationTarget {
13983 if(!isWasmInitialized) {
13984 throw new Error("initializeWasm() must be awaited first!");
13986 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
13987 return nativeResponseValue;
13989 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
13991 export function ConfirmationTarget_normal(): ConfirmationTarget {
13992 if(!isWasmInitialized) {
13993 throw new Error("initializeWasm() must be awaited first!");
13995 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
13996 return nativeResponseValue;
13998 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
14000 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
14001 if(!isWasmInitialized) {
14002 throw new Error("initializeWasm() must be awaited first!");
14004 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
14005 return nativeResponseValue;
14007 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
14009 export function ConfirmationTarget_eq(a: number, b: number): boolean {
14010 if(!isWasmInitialized) {
14011 throw new Error("initializeWasm() must be awaited first!");
14013 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
14014 return nativeResponseValue;
14016 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
14018 export function FeeEstimator_free(this_ptr: number): void {
14019 if(!isWasmInitialized) {
14020 throw new Error("initializeWasm() must be awaited first!");
14022 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
14023 // debug statements here
14025 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
14027 export function MonitorUpdateId_free(this_obj: number): void {
14028 if(!isWasmInitialized) {
14029 throw new Error("initializeWasm() must be awaited first!");
14031 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
14032 // debug statements here
14034 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
14036 export function MonitorUpdateId_clone_ptr(arg: number): number {
14037 if(!isWasmInitialized) {
14038 throw new Error("initializeWasm() must be awaited first!");
14040 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
14041 return nativeResponseValue;
14043 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
14045 export function MonitorUpdateId_clone(orig: number): number {
14046 if(!isWasmInitialized) {
14047 throw new Error("initializeWasm() must be awaited first!");
14049 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
14050 return nativeResponseValue;
14052 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
14054 export function MonitorUpdateId_hash(o: number): bigint {
14055 if(!isWasmInitialized) {
14056 throw new Error("initializeWasm() must be awaited first!");
14058 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
14059 return nativeResponseValue;
14061 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
14063 export function MonitorUpdateId_eq(a: number, b: number): boolean {
14064 if(!isWasmInitialized) {
14065 throw new Error("initializeWasm() must be awaited first!");
14067 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
14068 return nativeResponseValue;
14070 // void Persist_free(struct LDKPersist this_ptr);
14072 export function Persist_free(this_ptr: number): void {
14073 if(!isWasmInitialized) {
14074 throw new Error("initializeWasm() must be awaited first!");
14076 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
14077 // debug statements here
14079 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
14081 export function LockedChannelMonitor_free(this_obj: number): void {
14082 if(!isWasmInitialized) {
14083 throw new Error("initializeWasm() must be awaited first!");
14085 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
14086 // debug statements here
14088 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
14090 export function ChainMonitor_free(this_obj: number): void {
14091 if(!isWasmInitialized) {
14092 throw new Error("initializeWasm() must be awaited first!");
14094 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
14095 // debug statements here
14097 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
14099 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
14100 if(!isWasmInitialized) {
14101 throw new Error("initializeWasm() must be awaited first!");
14103 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
14104 return nativeResponseValue;
14106 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
14108 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
14109 if(!isWasmInitialized) {
14110 throw new Error("initializeWasm() must be awaited first!");
14112 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
14113 return nativeResponseValue;
14115 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
14117 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
14118 if(!isWasmInitialized) {
14119 throw new Error("initializeWasm() must be awaited first!");
14121 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
14122 return nativeResponseValue;
14124 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14126 export function ChainMonitor_list_monitors(this_arg: number): number {
14127 if(!isWasmInitialized) {
14128 throw new Error("initializeWasm() must be awaited first!");
14130 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
14131 return nativeResponseValue;
14133 // 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);
14135 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
14136 if(!isWasmInitialized) {
14137 throw new Error("initializeWasm() must be awaited first!");
14139 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
14140 return nativeResponseValue;
14142 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14144 export function ChainMonitor_as_Listen(this_arg: number): number {
14145 if(!isWasmInitialized) {
14146 throw new Error("initializeWasm() must be awaited first!");
14148 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
14149 return nativeResponseValue;
14151 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14153 export function ChainMonitor_as_Confirm(this_arg: number): number {
14154 if(!isWasmInitialized) {
14155 throw new Error("initializeWasm() must be awaited first!");
14157 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
14158 return nativeResponseValue;
14160 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14162 export function ChainMonitor_as_Watch(this_arg: number): number {
14163 if(!isWasmInitialized) {
14164 throw new Error("initializeWasm() must be awaited first!");
14166 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
14167 return nativeResponseValue;
14169 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
14171 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
14172 if(!isWasmInitialized) {
14173 throw new Error("initializeWasm() must be awaited first!");
14175 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
14176 return nativeResponseValue;
14178 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
14180 export function ChannelMonitorUpdate_free(this_obj: number): void {
14181 if(!isWasmInitialized) {
14182 throw new Error("initializeWasm() must be awaited first!");
14184 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
14185 // debug statements here
14187 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
14189 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
14190 if(!isWasmInitialized) {
14191 throw new Error("initializeWasm() must be awaited first!");
14193 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
14194 return nativeResponseValue;
14196 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
14198 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
14199 if(!isWasmInitialized) {
14200 throw new Error("initializeWasm() must be awaited first!");
14202 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
14203 // debug statements here
14205 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
14207 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
14208 if(!isWasmInitialized) {
14209 throw new Error("initializeWasm() must be awaited first!");
14211 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
14212 return nativeResponseValue;
14214 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
14216 export function ChannelMonitorUpdate_clone(orig: number): number {
14217 if(!isWasmInitialized) {
14218 throw new Error("initializeWasm() must be awaited first!");
14220 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
14221 return nativeResponseValue;
14223 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
14225 export function ChannelMonitorUpdate_write(obj: number): number {
14226 if(!isWasmInitialized) {
14227 throw new Error("initializeWasm() must be awaited first!");
14229 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
14230 return nativeResponseValue;
14232 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
14234 export function ChannelMonitorUpdate_read(ser: number): number {
14235 if(!isWasmInitialized) {
14236 throw new Error("initializeWasm() must be awaited first!");
14238 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
14239 return nativeResponseValue;
14241 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
14243 export function MonitorEvent_free(this_ptr: number): void {
14244 if(!isWasmInitialized) {
14245 throw new Error("initializeWasm() must be awaited first!");
14247 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
14248 // debug statements here
14250 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
14252 export function MonitorEvent_clone_ptr(arg: number): number {
14253 if(!isWasmInitialized) {
14254 throw new Error("initializeWasm() must be awaited first!");
14256 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
14257 return nativeResponseValue;
14259 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
14261 export function MonitorEvent_clone(orig: number): number {
14262 if(!isWasmInitialized) {
14263 throw new Error("initializeWasm() must be awaited first!");
14265 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
14266 return nativeResponseValue;
14268 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
14270 export function MonitorEvent_htlcevent(a: number): number {
14271 if(!isWasmInitialized) {
14272 throw new Error("initializeWasm() must be awaited first!");
14274 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
14275 return nativeResponseValue;
14277 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
14279 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
14280 if(!isWasmInitialized) {
14281 throw new Error("initializeWasm() must be awaited first!");
14283 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
14284 return nativeResponseValue;
14286 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
14288 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
14289 if(!isWasmInitialized) {
14290 throw new Error("initializeWasm() must be awaited first!");
14292 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
14293 return nativeResponseValue;
14295 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
14297 export function MonitorEvent_update_failed(a: number): number {
14298 if(!isWasmInitialized) {
14299 throw new Error("initializeWasm() must be awaited first!");
14301 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
14302 return nativeResponseValue;
14304 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
14306 export function MonitorEvent_write(obj: number): number {
14307 if(!isWasmInitialized) {
14308 throw new Error("initializeWasm() must be awaited first!");
14310 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
14311 return nativeResponseValue;
14313 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
14315 export function MonitorEvent_read(ser: number): number {
14316 if(!isWasmInitialized) {
14317 throw new Error("initializeWasm() must be awaited first!");
14319 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
14320 return nativeResponseValue;
14322 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
14324 export function HTLCUpdate_free(this_obj: number): void {
14325 if(!isWasmInitialized) {
14326 throw new Error("initializeWasm() must be awaited first!");
14328 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
14329 // debug statements here
14331 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
14333 export function HTLCUpdate_clone_ptr(arg: number): number {
14334 if(!isWasmInitialized) {
14335 throw new Error("initializeWasm() must be awaited first!");
14337 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
14338 return nativeResponseValue;
14340 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
14342 export function HTLCUpdate_clone(orig: number): number {
14343 if(!isWasmInitialized) {
14344 throw new Error("initializeWasm() must be awaited first!");
14346 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
14347 return nativeResponseValue;
14349 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
14351 export function HTLCUpdate_write(obj: number): number {
14352 if(!isWasmInitialized) {
14353 throw new Error("initializeWasm() must be awaited first!");
14355 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
14356 return nativeResponseValue;
14358 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
14360 export function HTLCUpdate_read(ser: number): number {
14361 if(!isWasmInitialized) {
14362 throw new Error("initializeWasm() must be awaited first!");
14364 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
14365 return nativeResponseValue;
14367 // void Balance_free(struct LDKBalance this_ptr);
14369 export function Balance_free(this_ptr: number): void {
14370 if(!isWasmInitialized) {
14371 throw new Error("initializeWasm() must be awaited first!");
14373 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
14374 // debug statements here
14376 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
14378 export function Balance_clone_ptr(arg: number): number {
14379 if(!isWasmInitialized) {
14380 throw new Error("initializeWasm() must be awaited first!");
14382 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
14383 return nativeResponseValue;
14385 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
14387 export function Balance_clone(orig: number): number {
14388 if(!isWasmInitialized) {
14389 throw new Error("initializeWasm() must be awaited first!");
14391 const nativeResponseValue = wasm.TS_Balance_clone(orig);
14392 return nativeResponseValue;
14394 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
14396 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
14397 if(!isWasmInitialized) {
14398 throw new Error("initializeWasm() must be awaited first!");
14400 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
14401 return nativeResponseValue;
14403 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
14405 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
14406 if(!isWasmInitialized) {
14407 throw new Error("initializeWasm() must be awaited first!");
14409 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
14410 return nativeResponseValue;
14412 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
14414 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
14415 if(!isWasmInitialized) {
14416 throw new Error("initializeWasm() must be awaited first!");
14418 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
14419 return nativeResponseValue;
14421 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
14423 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
14424 if(!isWasmInitialized) {
14425 throw new Error("initializeWasm() must be awaited first!");
14427 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
14428 return nativeResponseValue;
14430 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
14432 export function Balance_eq(a: number, b: number): boolean {
14433 if(!isWasmInitialized) {
14434 throw new Error("initializeWasm() must be awaited first!");
14436 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
14437 return nativeResponseValue;
14439 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
14441 export function ChannelMonitor_free(this_obj: number): void {
14442 if(!isWasmInitialized) {
14443 throw new Error("initializeWasm() must be awaited first!");
14445 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
14446 // debug statements here
14448 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
14450 export function ChannelMonitor_clone_ptr(arg: number): number {
14451 if(!isWasmInitialized) {
14452 throw new Error("initializeWasm() must be awaited first!");
14454 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
14455 return nativeResponseValue;
14457 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
14459 export function ChannelMonitor_clone(orig: number): number {
14460 if(!isWasmInitialized) {
14461 throw new Error("initializeWasm() must be awaited first!");
14463 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
14464 return nativeResponseValue;
14466 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
14468 export function ChannelMonitor_write(obj: number): number {
14469 if(!isWasmInitialized) {
14470 throw new Error("initializeWasm() must be awaited first!");
14472 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
14473 return nativeResponseValue;
14475 // 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);
14477 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
14478 if(!isWasmInitialized) {
14479 throw new Error("initializeWasm() must be awaited first!");
14481 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
14482 return nativeResponseValue;
14484 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14486 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
14487 if(!isWasmInitialized) {
14488 throw new Error("initializeWasm() must be awaited first!");
14490 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
14491 return nativeResponseValue;
14493 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14495 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
14496 if(!isWasmInitialized) {
14497 throw new Error("initializeWasm() must be awaited first!");
14499 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
14500 return nativeResponseValue;
14502 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14504 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
14505 if(!isWasmInitialized) {
14506 throw new Error("initializeWasm() must be awaited first!");
14508 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
14509 return nativeResponseValue;
14511 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
14513 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
14514 if(!isWasmInitialized) {
14515 throw new Error("initializeWasm() must be awaited first!");
14517 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
14518 // debug statements here
14520 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14522 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
14523 if(!isWasmInitialized) {
14524 throw new Error("initializeWasm() must be awaited first!");
14526 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
14527 return nativeResponseValue;
14529 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14531 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
14532 if(!isWasmInitialized) {
14533 throw new Error("initializeWasm() must be awaited first!");
14535 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
14536 return nativeResponseValue;
14538 // 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);
14540 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
14541 if(!isWasmInitialized) {
14542 throw new Error("initializeWasm() must be awaited first!");
14544 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
14545 return nativeResponseValue;
14547 // 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);
14549 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
14550 if(!isWasmInitialized) {
14551 throw new Error("initializeWasm() must be awaited first!");
14553 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
14554 return nativeResponseValue;
14556 // 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);
14558 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
14559 if(!isWasmInitialized) {
14560 throw new Error("initializeWasm() must be awaited first!");
14562 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
14563 // debug statements here
14565 // 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);
14567 export function ChannelMonitor_transactions_confirmed(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_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
14572 return nativeResponseValue;
14574 // 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);
14576 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: 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_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
14581 // debug statements here
14583 // 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);
14585 export function ChannelMonitor_best_block_updated(this_arg: number, header: 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_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
14590 return nativeResponseValue;
14592 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14594 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
14595 if(!isWasmInitialized) {
14596 throw new Error("initializeWasm() must be awaited first!");
14598 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
14599 return nativeResponseValue;
14601 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14603 export function ChannelMonitor_current_best_block(this_arg: number): number {
14604 if(!isWasmInitialized) {
14605 throw new Error("initializeWasm() must be awaited first!");
14607 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
14608 return nativeResponseValue;
14610 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
14612 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
14613 if(!isWasmInitialized) {
14614 throw new Error("initializeWasm() must be awaited first!");
14616 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
14617 return nativeResponseValue;
14619 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
14621 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
14622 if(!isWasmInitialized) {
14623 throw new Error("initializeWasm() must be awaited first!");
14625 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
14626 return nativeResponseValue;
14628 // void OutPoint_free(struct LDKOutPoint this_obj);
14630 export function OutPoint_free(this_obj: number): void {
14631 if(!isWasmInitialized) {
14632 throw new Error("initializeWasm() must be awaited first!");
14634 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
14635 // debug statements here
14637 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
14639 export function OutPoint_get_txid(this_ptr: number): number {
14640 if(!isWasmInitialized) {
14641 throw new Error("initializeWasm() must be awaited first!");
14643 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
14644 return nativeResponseValue;
14646 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
14648 export function OutPoint_set_txid(this_ptr: number, val: number): void {
14649 if(!isWasmInitialized) {
14650 throw new Error("initializeWasm() must be awaited first!");
14652 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
14653 // debug statements here
14655 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
14657 export function OutPoint_get_index(this_ptr: number): number {
14658 if(!isWasmInitialized) {
14659 throw new Error("initializeWasm() must be awaited first!");
14661 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
14662 return nativeResponseValue;
14664 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
14666 export function OutPoint_set_index(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_index(this_ptr, val);
14671 // debug statements here
14673 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
14675 export function OutPoint_new(txid_arg: number, index_arg: number): number {
14676 if(!isWasmInitialized) {
14677 throw new Error("initializeWasm() must be awaited first!");
14679 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
14680 return nativeResponseValue;
14682 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
14684 export function OutPoint_clone_ptr(arg: number): number {
14685 if(!isWasmInitialized) {
14686 throw new Error("initializeWasm() must be awaited first!");
14688 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
14689 return nativeResponseValue;
14691 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
14693 export function OutPoint_clone(orig: number): number {
14694 if(!isWasmInitialized) {
14695 throw new Error("initializeWasm() must be awaited first!");
14697 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
14698 return nativeResponseValue;
14700 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
14702 export function OutPoint_eq(a: number, b: number): boolean {
14703 if(!isWasmInitialized) {
14704 throw new Error("initializeWasm() must be awaited first!");
14706 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
14707 return nativeResponseValue;
14709 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
14711 export function OutPoint_hash(o: number): bigint {
14712 if(!isWasmInitialized) {
14713 throw new Error("initializeWasm() must be awaited first!");
14715 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
14716 return nativeResponseValue;
14718 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
14720 export function OutPoint_to_channel_id(this_arg: number): number {
14721 if(!isWasmInitialized) {
14722 throw new Error("initializeWasm() must be awaited first!");
14724 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
14725 return nativeResponseValue;
14727 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
14729 export function OutPoint_write(obj: number): number {
14730 if(!isWasmInitialized) {
14731 throw new Error("initializeWasm() must be awaited first!");
14733 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
14734 return nativeResponseValue;
14736 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
14738 export function OutPoint_read(ser: number): number {
14739 if(!isWasmInitialized) {
14740 throw new Error("initializeWasm() must be awaited first!");
14742 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
14743 return nativeResponseValue;
14745 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
14747 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
14748 if(!isWasmInitialized) {
14749 throw new Error("initializeWasm() must be awaited first!");
14751 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
14752 // debug statements here
14754 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14756 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
14757 if(!isWasmInitialized) {
14758 throw new Error("initializeWasm() must be awaited first!");
14760 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
14761 return nativeResponseValue;
14763 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
14765 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
14766 if(!isWasmInitialized) {
14767 throw new Error("initializeWasm() must be awaited first!");
14769 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
14770 // debug statements here
14772 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14774 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
14775 if(!isWasmInitialized) {
14776 throw new Error("initializeWasm() must be awaited first!");
14778 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
14779 return nativeResponseValue;
14781 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
14783 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(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_per_commitment_point(this_ptr, val);
14788 // debug statements here
14790 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14792 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
14793 if(!isWasmInitialized) {
14794 throw new Error("initializeWasm() must be awaited first!");
14796 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
14797 return nativeResponseValue;
14799 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
14801 export function DelayedPaymentOutputDescriptor_set_to_self_delay(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_to_self_delay(this_ptr, val);
14806 // debug statements here
14808 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
14810 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
14811 if(!isWasmInitialized) {
14812 throw new Error("initializeWasm() must be awaited first!");
14814 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
14815 // debug statements here
14817 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14819 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
14820 if(!isWasmInitialized) {
14821 throw new Error("initializeWasm() must be awaited first!");
14823 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
14824 return nativeResponseValue;
14826 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
14828 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(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_revocation_pubkey(this_ptr, val);
14833 // debug statements here
14835 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
14837 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
14838 if(!isWasmInitialized) {
14839 throw new Error("initializeWasm() must be awaited first!");
14841 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
14842 return nativeResponseValue;
14844 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
14846 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(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_channel_keys_id(this_ptr, val);
14851 // debug statements here
14853 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14855 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
14856 if(!isWasmInitialized) {
14857 throw new Error("initializeWasm() must be awaited first!");
14859 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
14860 return nativeResponseValue;
14862 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
14864 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
14865 if(!isWasmInitialized) {
14866 throw new Error("initializeWasm() must be awaited first!");
14868 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
14869 // debug statements here
14871 // 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);
14873 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 {
14874 if(!isWasmInitialized) {
14875 throw new Error("initializeWasm() must be awaited first!");
14877 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);
14878 return nativeResponseValue;
14880 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
14882 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
14883 if(!isWasmInitialized) {
14884 throw new Error("initializeWasm() must be awaited first!");
14886 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
14887 return nativeResponseValue;
14889 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
14891 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
14892 if(!isWasmInitialized) {
14893 throw new Error("initializeWasm() must be awaited first!");
14895 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
14896 return nativeResponseValue;
14898 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
14900 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
14901 if(!isWasmInitialized) {
14902 throw new Error("initializeWasm() must be awaited first!");
14904 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
14905 return nativeResponseValue;
14907 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
14909 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
14910 if(!isWasmInitialized) {
14911 throw new Error("initializeWasm() must be awaited first!");
14913 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
14914 return nativeResponseValue;
14916 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
14918 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
14919 if(!isWasmInitialized) {
14920 throw new Error("initializeWasm() must be awaited first!");
14922 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
14923 // debug statements here
14925 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14927 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
14928 if(!isWasmInitialized) {
14929 throw new Error("initializeWasm() must be awaited first!");
14931 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
14932 return nativeResponseValue;
14934 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
14936 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
14937 if(!isWasmInitialized) {
14938 throw new Error("initializeWasm() must be awaited first!");
14940 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
14941 // debug statements here
14943 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
14945 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
14946 if(!isWasmInitialized) {
14947 throw new Error("initializeWasm() must be awaited first!");
14949 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
14950 // debug statements here
14952 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
14954 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
14955 if(!isWasmInitialized) {
14956 throw new Error("initializeWasm() must be awaited first!");
14958 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
14959 return nativeResponseValue;
14961 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
14963 export function StaticPaymentOutputDescriptor_set_channel_keys_id(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_channel_keys_id(this_ptr, val);
14968 // debug statements here
14970 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
14972 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
14973 if(!isWasmInitialized) {
14974 throw new Error("initializeWasm() must be awaited first!");
14976 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
14977 return nativeResponseValue;
14979 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
14981 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
14982 if(!isWasmInitialized) {
14983 throw new Error("initializeWasm() must be awaited first!");
14985 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
14986 // debug statements here
14988 // 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);
14990 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
14991 if(!isWasmInitialized) {
14992 throw new Error("initializeWasm() must be awaited first!");
14994 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
14995 return nativeResponseValue;
14997 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
14999 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
15000 if(!isWasmInitialized) {
15001 throw new Error("initializeWasm() must be awaited first!");
15003 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
15004 return nativeResponseValue;
15006 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
15008 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
15009 if(!isWasmInitialized) {
15010 throw new Error("initializeWasm() must be awaited first!");
15012 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
15013 return nativeResponseValue;
15015 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
15017 export function StaticPaymentOutputDescriptor_write(obj: number): number {
15018 if(!isWasmInitialized) {
15019 throw new Error("initializeWasm() must be awaited first!");
15021 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
15022 return nativeResponseValue;
15024 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
15026 export function StaticPaymentOutputDescriptor_read(ser: number): number {
15027 if(!isWasmInitialized) {
15028 throw new Error("initializeWasm() must be awaited first!");
15030 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
15031 return nativeResponseValue;
15033 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
15035 export function SpendableOutputDescriptor_free(this_ptr: number): void {
15036 if(!isWasmInitialized) {
15037 throw new Error("initializeWasm() must be awaited first!");
15039 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
15040 // debug statements here
15042 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
15044 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
15045 if(!isWasmInitialized) {
15046 throw new Error("initializeWasm() must be awaited first!");
15048 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
15049 return nativeResponseValue;
15051 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
15053 export function SpendableOutputDescriptor_clone(orig: number): number {
15054 if(!isWasmInitialized) {
15055 throw new Error("initializeWasm() must be awaited first!");
15057 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
15058 return nativeResponseValue;
15060 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
15062 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
15063 if(!isWasmInitialized) {
15064 throw new Error("initializeWasm() must be awaited first!");
15066 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
15067 return nativeResponseValue;
15069 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
15071 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
15072 if(!isWasmInitialized) {
15073 throw new Error("initializeWasm() must be awaited first!");
15075 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
15076 return nativeResponseValue;
15078 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
15080 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
15081 if(!isWasmInitialized) {
15082 throw new Error("initializeWasm() must be awaited first!");
15084 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
15085 return nativeResponseValue;
15087 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
15089 export function SpendableOutputDescriptor_write(obj: number): number {
15090 if(!isWasmInitialized) {
15091 throw new Error("initializeWasm() must be awaited first!");
15093 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
15094 return nativeResponseValue;
15096 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
15098 export function SpendableOutputDescriptor_read(ser: number): number {
15099 if(!isWasmInitialized) {
15100 throw new Error("initializeWasm() must be awaited first!");
15102 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
15103 return nativeResponseValue;
15105 // void BaseSign_free(struct LDKBaseSign this_ptr);
15107 export function BaseSign_free(this_ptr: number): void {
15108 if(!isWasmInitialized) {
15109 throw new Error("initializeWasm() must be awaited first!");
15111 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
15112 // debug statements here
15114 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
15116 export function Sign_clone_ptr(arg: number): number {
15117 if(!isWasmInitialized) {
15118 throw new Error("initializeWasm() must be awaited first!");
15120 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
15121 return nativeResponseValue;
15123 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
15125 export function Sign_clone(orig: number): number {
15126 if(!isWasmInitialized) {
15127 throw new Error("initializeWasm() must be awaited first!");
15129 const nativeResponseValue = wasm.TS_Sign_clone(orig);
15130 return nativeResponseValue;
15132 // void Sign_free(struct LDKSign this_ptr);
15134 export function Sign_free(this_ptr: number): void {
15135 if(!isWasmInitialized) {
15136 throw new Error("initializeWasm() must be awaited first!");
15138 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
15139 // debug statements here
15141 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
15143 export function KeysInterface_free(this_ptr: number): void {
15144 if(!isWasmInitialized) {
15145 throw new Error("initializeWasm() must be awaited first!");
15147 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
15148 // debug statements here
15150 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
15152 export function InMemorySigner_free(this_obj: number): void {
15153 if(!isWasmInitialized) {
15154 throw new Error("initializeWasm() must be awaited first!");
15156 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
15157 // debug statements here
15159 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15161 export function InMemorySigner_get_funding_key(this_ptr: number): number {
15162 if(!isWasmInitialized) {
15163 throw new Error("initializeWasm() must be awaited first!");
15165 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
15166 return nativeResponseValue;
15168 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15170 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
15171 if(!isWasmInitialized) {
15172 throw new Error("initializeWasm() must be awaited first!");
15174 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
15175 // debug statements here
15177 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15179 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
15180 if(!isWasmInitialized) {
15181 throw new Error("initializeWasm() must be awaited first!");
15183 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
15184 return nativeResponseValue;
15186 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15188 export function InMemorySigner_set_revocation_base_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_revocation_base_key(this_ptr, val);
15193 // debug statements here
15195 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15197 export function InMemorySigner_get_payment_key(this_ptr: number): number {
15198 if(!isWasmInitialized) {
15199 throw new Error("initializeWasm() must be awaited first!");
15201 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
15202 return nativeResponseValue;
15204 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15206 export function InMemorySigner_set_payment_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_payment_key(this_ptr, val);
15211 // debug statements here
15213 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15215 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
15216 if(!isWasmInitialized) {
15217 throw new Error("initializeWasm() must be awaited first!");
15219 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
15220 return nativeResponseValue;
15222 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15224 export function InMemorySigner_set_delayed_payment_base_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_delayed_payment_base_key(this_ptr, val);
15229 // debug statements here
15231 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15233 export function InMemorySigner_get_htlc_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_htlc_base_key(this_ptr);
15238 return nativeResponseValue;
15240 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
15242 export function InMemorySigner_set_htlc_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_htlc_base_key(this_ptr, val);
15247 // debug statements here
15249 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
15251 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
15252 if(!isWasmInitialized) {
15253 throw new Error("initializeWasm() must be awaited first!");
15255 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
15256 return nativeResponseValue;
15258 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
15260 export function InMemorySigner_set_commitment_seed(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_commitment_seed(this_ptr, val);
15265 // debug statements here
15267 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
15269 export function InMemorySigner_clone_ptr(arg: number): number {
15270 if(!isWasmInitialized) {
15271 throw new Error("initializeWasm() must be awaited first!");
15273 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
15274 return nativeResponseValue;
15276 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
15278 export function InMemorySigner_clone(orig: number): number {
15279 if(!isWasmInitialized) {
15280 throw new Error("initializeWasm() must be awaited first!");
15282 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
15283 return nativeResponseValue;
15285 // 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);
15287 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 {
15288 if(!isWasmInitialized) {
15289 throw new Error("initializeWasm() must be awaited first!");
15291 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);
15292 return nativeResponseValue;
15294 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15296 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
15297 if(!isWasmInitialized) {
15298 throw new Error("initializeWasm() must be awaited first!");
15300 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
15301 return nativeResponseValue;
15303 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15305 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
15306 if(!isWasmInitialized) {
15307 throw new Error("initializeWasm() must be awaited first!");
15309 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
15310 return nativeResponseValue;
15312 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15314 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
15315 if(!isWasmInitialized) {
15316 throw new Error("initializeWasm() must be awaited first!");
15318 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
15319 return nativeResponseValue;
15321 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15323 export function InMemorySigner_is_outbound(this_arg: number): boolean {
15324 if(!isWasmInitialized) {
15325 throw new Error("initializeWasm() must be awaited first!");
15327 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
15328 return nativeResponseValue;
15330 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15332 export function InMemorySigner_funding_outpoint(this_arg: number): number {
15333 if(!isWasmInitialized) {
15334 throw new Error("initializeWasm() must be awaited first!");
15336 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
15337 return nativeResponseValue;
15339 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15341 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
15342 if(!isWasmInitialized) {
15343 throw new Error("initializeWasm() must be awaited first!");
15345 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
15346 return nativeResponseValue;
15348 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15350 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
15351 if(!isWasmInitialized) {
15352 throw new Error("initializeWasm() must be awaited first!");
15354 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
15355 return nativeResponseValue;
15357 // 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);
15359 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
15360 if(!isWasmInitialized) {
15361 throw new Error("initializeWasm() must be awaited first!");
15363 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
15364 return nativeResponseValue;
15366 // 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);
15368 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
15369 if(!isWasmInitialized) {
15370 throw new Error("initializeWasm() must be awaited first!");
15372 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
15373 return nativeResponseValue;
15375 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15377 export function InMemorySigner_as_BaseSign(this_arg: number): number {
15378 if(!isWasmInitialized) {
15379 throw new Error("initializeWasm() must be awaited first!");
15381 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
15382 return nativeResponseValue;
15384 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
15386 export function InMemorySigner_as_Sign(this_arg: number): number {
15387 if(!isWasmInitialized) {
15388 throw new Error("initializeWasm() must be awaited first!");
15390 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
15391 return nativeResponseValue;
15393 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
15395 export function InMemorySigner_write(obj: number): number {
15396 if(!isWasmInitialized) {
15397 throw new Error("initializeWasm() must be awaited first!");
15399 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
15400 return nativeResponseValue;
15402 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser);
15404 export function InMemorySigner_read(ser: number): number {
15405 if(!isWasmInitialized) {
15406 throw new Error("initializeWasm() must be awaited first!");
15408 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser);
15409 return nativeResponseValue;
15411 // void KeysManager_free(struct LDKKeysManager this_obj);
15413 export function KeysManager_free(this_obj: number): void {
15414 if(!isWasmInitialized) {
15415 throw new Error("initializeWasm() must be awaited first!");
15417 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
15418 // debug statements here
15420 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
15422 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
15423 if(!isWasmInitialized) {
15424 throw new Error("initializeWasm() must be awaited first!");
15426 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
15427 return nativeResponseValue;
15429 // 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]);
15431 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
15432 if(!isWasmInitialized) {
15433 throw new Error("initializeWasm() must be awaited first!");
15435 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
15436 return nativeResponseValue;
15438 // 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);
15440 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
15441 if(!isWasmInitialized) {
15442 throw new Error("initializeWasm() must be awaited first!");
15444 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
15445 return nativeResponseValue;
15447 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
15449 export function KeysManager_as_KeysInterface(this_arg: number): number {
15450 if(!isWasmInitialized) {
15451 throw new Error("initializeWasm() must be awaited first!");
15453 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
15454 return nativeResponseValue;
15456 // void ChannelManager_free(struct LDKChannelManager this_obj);
15458 export function ChannelManager_free(this_obj: number): void {
15459 if(!isWasmInitialized) {
15460 throw new Error("initializeWasm() must be awaited first!");
15462 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
15463 // debug statements here
15465 // void ChainParameters_free(struct LDKChainParameters this_obj);
15467 export function ChainParameters_free(this_obj: number): void {
15468 if(!isWasmInitialized) {
15469 throw new Error("initializeWasm() must be awaited first!");
15471 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
15472 // debug statements here
15474 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
15476 export function ChainParameters_get_network(this_ptr: number): Network {
15477 if(!isWasmInitialized) {
15478 throw new Error("initializeWasm() must be awaited first!");
15480 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
15481 return nativeResponseValue;
15483 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
15485 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
15486 if(!isWasmInitialized) {
15487 throw new Error("initializeWasm() must be awaited first!");
15489 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
15490 // debug statements here
15492 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
15494 export function ChainParameters_get_best_block(this_ptr: number): number {
15495 if(!isWasmInitialized) {
15496 throw new Error("initializeWasm() must be awaited first!");
15498 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
15499 return nativeResponseValue;
15501 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
15503 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
15504 if(!isWasmInitialized) {
15505 throw new Error("initializeWasm() must be awaited first!");
15507 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
15508 // debug statements here
15510 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
15512 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
15513 if(!isWasmInitialized) {
15514 throw new Error("initializeWasm() must be awaited first!");
15516 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
15517 return nativeResponseValue;
15519 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
15521 export function ChainParameters_clone_ptr(arg: number): number {
15522 if(!isWasmInitialized) {
15523 throw new Error("initializeWasm() must be awaited first!");
15525 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
15526 return nativeResponseValue;
15528 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
15530 export function ChainParameters_clone(orig: number): number {
15531 if(!isWasmInitialized) {
15532 throw new Error("initializeWasm() must be awaited first!");
15534 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
15535 return nativeResponseValue;
15537 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
15539 export function CounterpartyForwardingInfo_free(this_obj: number): void {
15540 if(!isWasmInitialized) {
15541 throw new Error("initializeWasm() must be awaited first!");
15543 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
15544 // debug statements here
15546 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
15548 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
15549 if(!isWasmInitialized) {
15550 throw new Error("initializeWasm() must be awaited first!");
15552 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
15553 return nativeResponseValue;
15555 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
15557 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
15558 if(!isWasmInitialized) {
15559 throw new Error("initializeWasm() must be awaited first!");
15561 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
15562 // debug statements here
15564 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
15566 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
15567 if(!isWasmInitialized) {
15568 throw new Error("initializeWasm() must be awaited first!");
15570 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
15571 return nativeResponseValue;
15573 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
15575 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(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_proportional_millionths(this_ptr, val);
15580 // debug statements here
15582 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
15584 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
15585 if(!isWasmInitialized) {
15586 throw new Error("initializeWasm() must be awaited first!");
15588 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
15589 return nativeResponseValue;
15591 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
15593 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(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_cltv_expiry_delta(this_ptr, val);
15598 // debug statements here
15600 // 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);
15602 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
15603 if(!isWasmInitialized) {
15604 throw new Error("initializeWasm() must be awaited first!");
15606 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
15607 return nativeResponseValue;
15609 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
15611 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
15612 if(!isWasmInitialized) {
15613 throw new Error("initializeWasm() must be awaited first!");
15615 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
15616 return nativeResponseValue;
15618 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
15620 export function CounterpartyForwardingInfo_clone(orig: number): number {
15621 if(!isWasmInitialized) {
15622 throw new Error("initializeWasm() must be awaited first!");
15624 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
15625 return nativeResponseValue;
15627 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
15629 export function ChannelCounterparty_free(this_obj: number): void {
15630 if(!isWasmInitialized) {
15631 throw new Error("initializeWasm() must be awaited first!");
15633 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
15634 // debug statements here
15636 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15638 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
15639 if(!isWasmInitialized) {
15640 throw new Error("initializeWasm() must be awaited first!");
15642 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
15643 return nativeResponseValue;
15645 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
15647 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
15648 if(!isWasmInitialized) {
15649 throw new Error("initializeWasm() must be awaited first!");
15651 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
15652 // debug statements here
15654 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15656 export function ChannelCounterparty_get_features(this_ptr: number): number {
15657 if(!isWasmInitialized) {
15658 throw new Error("initializeWasm() must be awaited first!");
15660 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
15661 return nativeResponseValue;
15663 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
15665 export function ChannelCounterparty_set_features(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_features(this_ptr, val);
15670 // debug statements here
15672 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15674 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
15675 if(!isWasmInitialized) {
15676 throw new Error("initializeWasm() must be awaited first!");
15678 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
15679 return nativeResponseValue;
15681 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
15683 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
15684 if(!isWasmInitialized) {
15685 throw new Error("initializeWasm() must be awaited first!");
15687 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
15688 // debug statements here
15690 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
15692 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
15693 if(!isWasmInitialized) {
15694 throw new Error("initializeWasm() must be awaited first!");
15696 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
15697 return nativeResponseValue;
15699 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
15701 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
15702 if(!isWasmInitialized) {
15703 throw new Error("initializeWasm() must be awaited first!");
15705 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
15706 // debug statements here
15708 // 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);
15710 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number): number {
15711 if(!isWasmInitialized) {
15712 throw new Error("initializeWasm() must be awaited first!");
15714 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
15715 return nativeResponseValue;
15717 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
15719 export function ChannelCounterparty_clone_ptr(arg: number): number {
15720 if(!isWasmInitialized) {
15721 throw new Error("initializeWasm() must be awaited first!");
15723 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
15724 return nativeResponseValue;
15726 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
15728 export function ChannelCounterparty_clone(orig: number): number {
15729 if(!isWasmInitialized) {
15730 throw new Error("initializeWasm() must be awaited first!");
15732 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
15733 return nativeResponseValue;
15735 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
15737 export function ChannelDetails_free(this_obj: number): void {
15738 if(!isWasmInitialized) {
15739 throw new Error("initializeWasm() must be awaited first!");
15741 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
15742 // debug statements here
15744 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
15746 export function ChannelDetails_get_channel_id(this_ptr: number): number {
15747 if(!isWasmInitialized) {
15748 throw new Error("initializeWasm() must be awaited first!");
15750 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
15751 return nativeResponseValue;
15753 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
15755 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
15756 if(!isWasmInitialized) {
15757 throw new Error("initializeWasm() must be awaited first!");
15759 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
15760 // debug statements here
15762 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15764 export function ChannelDetails_get_counterparty(this_ptr: number): number {
15765 if(!isWasmInitialized) {
15766 throw new Error("initializeWasm() must be awaited first!");
15768 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
15769 return nativeResponseValue;
15771 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
15773 export function ChannelDetails_set_counterparty(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_counterparty(this_ptr, val);
15778 // debug statements here
15780 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15782 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
15783 if(!isWasmInitialized) {
15784 throw new Error("initializeWasm() must be awaited first!");
15786 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
15787 return nativeResponseValue;
15789 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
15791 export function ChannelDetails_set_funding_txo(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_funding_txo(this_ptr, val);
15796 // debug statements here
15798 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15800 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
15801 if(!isWasmInitialized) {
15802 throw new Error("initializeWasm() must be awaited first!");
15804 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
15805 return nativeResponseValue;
15807 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
15809 export function ChannelDetails_set_short_channel_id(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_short_channel_id(this_ptr, val);
15814 // debug statements here
15816 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15818 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
15819 if(!isWasmInitialized) {
15820 throw new Error("initializeWasm() must be awaited first!");
15822 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
15823 return nativeResponseValue;
15825 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15827 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
15828 if(!isWasmInitialized) {
15829 throw new Error("initializeWasm() must be awaited first!");
15831 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
15832 // debug statements here
15834 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15836 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
15837 if(!isWasmInitialized) {
15838 throw new Error("initializeWasm() must be awaited first!");
15840 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
15841 return nativeResponseValue;
15843 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
15845 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
15846 if(!isWasmInitialized) {
15847 throw new Error("initializeWasm() must be awaited first!");
15849 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
15850 // debug statements here
15852 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15854 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
15855 if(!isWasmInitialized) {
15856 throw new Error("initializeWasm() must be awaited first!");
15858 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
15859 return nativeResponseValue;
15861 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15863 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
15864 if(!isWasmInitialized) {
15865 throw new Error("initializeWasm() must be awaited first!");
15867 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
15868 // debug statements here
15870 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15872 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
15873 if(!isWasmInitialized) {
15874 throw new Error("initializeWasm() must be awaited first!");
15876 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
15877 return nativeResponseValue;
15879 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15881 export function ChannelDetails_set_balance_msat(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_balance_msat(this_ptr, val);
15886 // debug statements here
15888 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15890 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
15891 if(!isWasmInitialized) {
15892 throw new Error("initializeWasm() must be awaited first!");
15894 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
15895 return nativeResponseValue;
15897 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15899 export function ChannelDetails_set_outbound_capacity_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_outbound_capacity_msat(this_ptr, val);
15904 // debug statements here
15906 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15908 export function ChannelDetails_get_inbound_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_inbound_capacity_msat(this_ptr);
15913 return nativeResponseValue;
15915 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
15917 export function ChannelDetails_set_inbound_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_inbound_capacity_msat(this_ptr, val);
15922 // debug statements here
15924 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15926 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
15927 if(!isWasmInitialized) {
15928 throw new Error("initializeWasm() must be awaited first!");
15930 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
15931 return nativeResponseValue;
15933 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
15935 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
15936 if(!isWasmInitialized) {
15937 throw new Error("initializeWasm() must be awaited first!");
15939 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
15940 // debug statements here
15942 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15944 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
15945 if(!isWasmInitialized) {
15946 throw new Error("initializeWasm() must be awaited first!");
15948 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
15949 return nativeResponseValue;
15951 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
15953 export function ChannelDetails_set_force_close_spend_delay(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_force_close_spend_delay(this_ptr, val);
15958 // debug statements here
15960 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15962 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
15963 if(!isWasmInitialized) {
15964 throw new Error("initializeWasm() must be awaited first!");
15966 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
15967 return nativeResponseValue;
15969 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
15971 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
15972 if(!isWasmInitialized) {
15973 throw new Error("initializeWasm() must be awaited first!");
15975 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
15976 // debug statements here
15978 // bool ChannelDetails_get_is_funding_locked(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15980 export function ChannelDetails_get_is_funding_locked(this_ptr: number): boolean {
15981 if(!isWasmInitialized) {
15982 throw new Error("initializeWasm() must be awaited first!");
15984 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_funding_locked(this_ptr);
15985 return nativeResponseValue;
15987 // void ChannelDetails_set_is_funding_locked(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
15989 export function ChannelDetails_set_is_funding_locked(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_funding_locked(this_ptr, val);
15994 // debug statements here
15996 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
15998 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
15999 if(!isWasmInitialized) {
16000 throw new Error("initializeWasm() must be awaited first!");
16002 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
16003 return nativeResponseValue;
16005 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
16007 export function ChannelDetails_set_is_usable(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_usable(this_ptr, val);
16012 // debug statements here
16014 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
16016 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
16017 if(!isWasmInitialized) {
16018 throw new Error("initializeWasm() must be awaited first!");
16020 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
16021 return nativeResponseValue;
16023 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
16025 export function ChannelDetails_set_is_public(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_public(this_ptr, val);
16030 // debug statements here
16032 // 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);
16034 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 {
16035 if(!isWasmInitialized) {
16036 throw new Error("initializeWasm() must be awaited first!");
16038 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);
16039 return nativeResponseValue;
16041 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
16043 export function ChannelDetails_clone_ptr(arg: number): number {
16044 if(!isWasmInitialized) {
16045 throw new Error("initializeWasm() must be awaited first!");
16047 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
16048 return nativeResponseValue;
16050 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
16052 export function ChannelDetails_clone(orig: number): number {
16053 if(!isWasmInitialized) {
16054 throw new Error("initializeWasm() must be awaited first!");
16056 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
16057 return nativeResponseValue;
16059 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
16061 export function PaymentSendFailure_free(this_ptr: number): void {
16062 if(!isWasmInitialized) {
16063 throw new Error("initializeWasm() must be awaited first!");
16065 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
16066 // debug statements here
16068 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
16070 export function PaymentSendFailure_clone_ptr(arg: number): number {
16071 if(!isWasmInitialized) {
16072 throw new Error("initializeWasm() must be awaited first!");
16074 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
16075 return nativeResponseValue;
16077 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
16079 export function PaymentSendFailure_clone(orig: number): number {
16080 if(!isWasmInitialized) {
16081 throw new Error("initializeWasm() must be awaited first!");
16083 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
16084 return nativeResponseValue;
16086 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
16088 export function PaymentSendFailure_parameter_error(a: number): number {
16089 if(!isWasmInitialized) {
16090 throw new Error("initializeWasm() must be awaited first!");
16092 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
16093 return nativeResponseValue;
16095 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
16097 export function PaymentSendFailure_path_parameter_error(a: number): number {
16098 if(!isWasmInitialized) {
16099 throw new Error("initializeWasm() must be awaited first!");
16101 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
16102 return nativeResponseValue;
16104 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
16106 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
16107 if(!isWasmInitialized) {
16108 throw new Error("initializeWasm() must be awaited first!");
16110 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
16111 return nativeResponseValue;
16113 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
16115 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
16116 if(!isWasmInitialized) {
16117 throw new Error("initializeWasm() must be awaited first!");
16119 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
16120 return nativeResponseValue;
16122 // 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);
16124 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
16125 if(!isWasmInitialized) {
16126 throw new Error("initializeWasm() must be awaited first!");
16128 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
16129 return nativeResponseValue;
16131 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
16133 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
16134 if(!isWasmInitialized) {
16135 throw new Error("initializeWasm() must be awaited first!");
16137 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
16138 return nativeResponseValue;
16140 // 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);
16142 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 {
16143 if(!isWasmInitialized) {
16144 throw new Error("initializeWasm() must be awaited first!");
16146 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
16147 return nativeResponseValue;
16149 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
16151 export function ChannelManager_list_channels(this_arg: number): number {
16152 if(!isWasmInitialized) {
16153 throw new Error("initializeWasm() must be awaited first!");
16155 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
16156 return nativeResponseValue;
16158 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
16160 export function ChannelManager_list_usable_channels(this_arg: number): number {
16161 if(!isWasmInitialized) {
16162 throw new Error("initializeWasm() must be awaited first!");
16164 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
16165 return nativeResponseValue;
16167 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
16169 export function ChannelManager_close_channel(this_arg: number, channel_id: number): number {
16170 if(!isWasmInitialized) {
16171 throw new Error("initializeWasm() must be awaited first!");
16173 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id);
16174 return nativeResponseValue;
16176 // 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);
16178 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, target_feerate_sats_per_1000_weight: number): number {
16179 if(!isWasmInitialized) {
16180 throw new Error("initializeWasm() must be awaited first!");
16182 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, target_feerate_sats_per_1000_weight);
16183 return nativeResponseValue;
16185 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
16187 export function ChannelManager_force_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_force_close_channel(this_arg, channel_id);
16192 return nativeResponseValue;
16194 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
16196 export function ChannelManager_force_close_all_channels(this_arg: number): void {
16197 if(!isWasmInitialized) {
16198 throw new Error("initializeWasm() must be awaited first!");
16200 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
16201 // debug statements here
16203 // 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);
16205 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
16206 if(!isWasmInitialized) {
16207 throw new Error("initializeWasm() must be awaited first!");
16209 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
16210 return nativeResponseValue;
16212 // 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);
16214 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
16215 if(!isWasmInitialized) {
16216 throw new Error("initializeWasm() must be awaited first!");
16218 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
16219 return nativeResponseValue;
16221 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
16223 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
16224 if(!isWasmInitialized) {
16225 throw new Error("initializeWasm() must be awaited first!");
16227 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
16228 // debug statements here
16230 // 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);
16232 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
16233 if(!isWasmInitialized) {
16234 throw new Error("initializeWasm() must be awaited first!");
16236 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
16237 return nativeResponseValue;
16239 // 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);
16241 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, funding_transaction: number): number {
16242 if(!isWasmInitialized) {
16243 throw new Error("initializeWasm() must be awaited first!");
16245 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, funding_transaction);
16246 return nativeResponseValue;
16248 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
16250 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
16251 if(!isWasmInitialized) {
16252 throw new Error("initializeWasm() must be awaited first!");
16254 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
16255 // debug statements here
16257 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
16259 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
16260 if(!isWasmInitialized) {
16261 throw new Error("initializeWasm() must be awaited first!");
16263 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
16264 // debug statements here
16266 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
16268 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
16269 if(!isWasmInitialized) {
16270 throw new Error("initializeWasm() must be awaited first!");
16272 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
16273 // debug statements here
16275 // MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
16277 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): boolean {
16278 if(!isWasmInitialized) {
16279 throw new Error("initializeWasm() must be awaited first!");
16281 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
16282 return nativeResponseValue;
16284 // MUST_USE_RES bool ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
16286 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): boolean {
16287 if(!isWasmInitialized) {
16288 throw new Error("initializeWasm() must be awaited first!");
16290 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
16291 return nativeResponseValue;
16293 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
16295 export function ChannelManager_get_our_node_id(this_arg: number): number {
16296 if(!isWasmInitialized) {
16297 throw new Error("initializeWasm() must be awaited first!");
16299 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
16300 return nativeResponseValue;
16302 // 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);
16304 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
16305 if(!isWasmInitialized) {
16306 throw new Error("initializeWasm() must be awaited first!");
16308 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
16309 return nativeResponseValue;
16311 // 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);
16313 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
16314 if(!isWasmInitialized) {
16315 throw new Error("initializeWasm() must be awaited first!");
16317 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
16318 return nativeResponseValue;
16320 // 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);
16322 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: 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_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
16327 return nativeResponseValue;
16329 // 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);
16331 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 {
16332 if(!isWasmInitialized) {
16333 throw new Error("initializeWasm() must be awaited first!");
16335 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
16336 return nativeResponseValue;
16338 // 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);
16340 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
16341 if(!isWasmInitialized) {
16342 throw new Error("initializeWasm() must be awaited first!");
16344 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
16345 return nativeResponseValue;
16347 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
16349 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
16350 if(!isWasmInitialized) {
16351 throw new Error("initializeWasm() must be awaited first!");
16353 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
16354 return nativeResponseValue;
16356 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
16358 export function ChannelManager_as_EventsProvider(this_arg: number): number {
16359 if(!isWasmInitialized) {
16360 throw new Error("initializeWasm() must be awaited first!");
16362 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
16363 return nativeResponseValue;
16365 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
16367 export function ChannelManager_as_Listen(this_arg: number): number {
16368 if(!isWasmInitialized) {
16369 throw new Error("initializeWasm() must be awaited first!");
16371 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
16372 return nativeResponseValue;
16374 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
16376 export function ChannelManager_as_Confirm(this_arg: number): number {
16377 if(!isWasmInitialized) {
16378 throw new Error("initializeWasm() must be awaited first!");
16380 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
16381 return nativeResponseValue;
16383 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
16385 export function ChannelManager_await_persistable_update(this_arg: number): void {
16386 if(!isWasmInitialized) {
16387 throw new Error("initializeWasm() must be awaited first!");
16389 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
16390 // debug statements here
16392 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
16394 export function ChannelManager_current_best_block(this_arg: number): number {
16395 if(!isWasmInitialized) {
16396 throw new Error("initializeWasm() must be awaited first!");
16398 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
16399 return nativeResponseValue;
16401 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
16403 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
16404 if(!isWasmInitialized) {
16405 throw new Error("initializeWasm() must be awaited first!");
16407 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
16408 return nativeResponseValue;
16410 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
16412 export function ChannelManager_write(obj: number): number {
16413 if(!isWasmInitialized) {
16414 throw new Error("initializeWasm() must be awaited first!");
16416 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
16417 return nativeResponseValue;
16419 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
16421 export function ChannelManagerReadArgs_free(this_obj: number): void {
16422 if(!isWasmInitialized) {
16423 throw new Error("initializeWasm() must be awaited first!");
16425 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
16426 // debug statements here
16428 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16430 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
16431 if(!isWasmInitialized) {
16432 throw new Error("initializeWasm() must be awaited first!");
16434 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
16435 return nativeResponseValue;
16437 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
16439 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
16440 if(!isWasmInitialized) {
16441 throw new Error("initializeWasm() must be awaited first!");
16443 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
16444 // debug statements here
16446 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16448 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
16449 if(!isWasmInitialized) {
16450 throw new Error("initializeWasm() must be awaited first!");
16452 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
16453 return nativeResponseValue;
16455 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
16457 export function ChannelManagerReadArgs_set_fee_estimator(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_fee_estimator(this_ptr, val);
16462 // debug statements here
16464 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16466 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
16467 if(!isWasmInitialized) {
16468 throw new Error("initializeWasm() must be awaited first!");
16470 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
16471 return nativeResponseValue;
16473 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
16475 export function ChannelManagerReadArgs_set_chain_monitor(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_chain_monitor(this_ptr, val);
16480 // debug statements here
16482 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16484 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
16485 if(!isWasmInitialized) {
16486 throw new Error("initializeWasm() must be awaited first!");
16488 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
16489 return nativeResponseValue;
16491 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
16493 export function ChannelManagerReadArgs_set_tx_broadcaster(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_tx_broadcaster(this_ptr, val);
16498 // debug statements here
16500 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16502 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
16503 if(!isWasmInitialized) {
16504 throw new Error("initializeWasm() must be awaited first!");
16506 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
16507 return nativeResponseValue;
16509 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
16511 export function ChannelManagerReadArgs_set_logger(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_logger(this_ptr, val);
16516 // debug statements here
16518 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
16520 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
16521 if(!isWasmInitialized) {
16522 throw new Error("initializeWasm() must be awaited first!");
16524 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
16525 return nativeResponseValue;
16527 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
16529 export function ChannelManagerReadArgs_set_default_config(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_default_config(this_ptr, val);
16534 // debug statements here
16536 // 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);
16538 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 {
16539 if(!isWasmInitialized) {
16540 throw new Error("initializeWasm() must be awaited first!");
16542 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
16543 return nativeResponseValue;
16545 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
16547 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
16548 if(!isWasmInitialized) {
16549 throw new Error("initializeWasm() must be awaited first!");
16551 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
16552 return nativeResponseValue;
16554 // void DecodeError_free(struct LDKDecodeError this_obj);
16556 export function DecodeError_free(this_obj: number): void {
16557 if(!isWasmInitialized) {
16558 throw new Error("initializeWasm() must be awaited first!");
16560 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
16561 // debug statements here
16563 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
16565 export function DecodeError_clone_ptr(arg: number): number {
16566 if(!isWasmInitialized) {
16567 throw new Error("initializeWasm() must be awaited first!");
16569 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
16570 return nativeResponseValue;
16572 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
16574 export function DecodeError_clone(orig: number): number {
16575 if(!isWasmInitialized) {
16576 throw new Error("initializeWasm() must be awaited first!");
16578 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
16579 return nativeResponseValue;
16581 // void Init_free(struct LDKInit this_obj);
16583 export function Init_free(this_obj: number): void {
16584 if(!isWasmInitialized) {
16585 throw new Error("initializeWasm() must be awaited first!");
16587 const nativeResponseValue = wasm.TS_Init_free(this_obj);
16588 // debug statements here
16590 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
16592 export function Init_get_features(this_ptr: number): number {
16593 if(!isWasmInitialized) {
16594 throw new Error("initializeWasm() must be awaited first!");
16596 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
16597 return nativeResponseValue;
16599 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
16601 export function Init_set_features(this_ptr: number, val: number): void {
16602 if(!isWasmInitialized) {
16603 throw new Error("initializeWasm() must be awaited first!");
16605 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
16606 // debug statements here
16608 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg);
16610 export function Init_new(features_arg: number): number {
16611 if(!isWasmInitialized) {
16612 throw new Error("initializeWasm() must be awaited first!");
16614 const nativeResponseValue = wasm.TS_Init_new(features_arg);
16615 return nativeResponseValue;
16617 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
16619 export function Init_clone_ptr(arg: number): number {
16620 if(!isWasmInitialized) {
16621 throw new Error("initializeWasm() must be awaited first!");
16623 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
16624 return nativeResponseValue;
16626 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
16628 export function Init_clone(orig: number): number {
16629 if(!isWasmInitialized) {
16630 throw new Error("initializeWasm() must be awaited first!");
16632 const nativeResponseValue = wasm.TS_Init_clone(orig);
16633 return nativeResponseValue;
16635 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
16637 export function ErrorMessage_free(this_obj: number): void {
16638 if(!isWasmInitialized) {
16639 throw new Error("initializeWasm() must be awaited first!");
16641 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
16642 // debug statements here
16644 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
16646 export function ErrorMessage_get_channel_id(this_ptr: number): number {
16647 if(!isWasmInitialized) {
16648 throw new Error("initializeWasm() must be awaited first!");
16650 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
16651 return nativeResponseValue;
16653 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16655 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
16656 if(!isWasmInitialized) {
16657 throw new Error("initializeWasm() must be awaited first!");
16659 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
16660 // debug statements here
16662 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
16664 export function ErrorMessage_get_data(this_ptr: number): number {
16665 if(!isWasmInitialized) {
16666 throw new Error("initializeWasm() must be awaited first!");
16668 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
16669 return nativeResponseValue;
16671 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
16673 export function ErrorMessage_set_data(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_data(this_ptr, val);
16678 // debug statements here
16680 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
16682 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
16683 if(!isWasmInitialized) {
16684 throw new Error("initializeWasm() must be awaited first!");
16686 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
16687 return nativeResponseValue;
16689 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
16691 export function ErrorMessage_clone_ptr(arg: number): number {
16692 if(!isWasmInitialized) {
16693 throw new Error("initializeWasm() must be awaited first!");
16695 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
16696 return nativeResponseValue;
16698 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
16700 export function ErrorMessage_clone(orig: number): number {
16701 if(!isWasmInitialized) {
16702 throw new Error("initializeWasm() must be awaited first!");
16704 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
16705 return nativeResponseValue;
16707 // void Ping_free(struct LDKPing this_obj);
16709 export function Ping_free(this_obj: number): void {
16710 if(!isWasmInitialized) {
16711 throw new Error("initializeWasm() must be awaited first!");
16713 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
16714 // debug statements here
16716 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
16718 export function Ping_get_ponglen(this_ptr: number): number {
16719 if(!isWasmInitialized) {
16720 throw new Error("initializeWasm() must be awaited first!");
16722 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
16723 return nativeResponseValue;
16725 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
16727 export function Ping_set_ponglen(this_ptr: number, val: number): void {
16728 if(!isWasmInitialized) {
16729 throw new Error("initializeWasm() must be awaited first!");
16731 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
16732 // debug statements here
16734 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
16736 export function Ping_get_byteslen(this_ptr: number): number {
16737 if(!isWasmInitialized) {
16738 throw new Error("initializeWasm() must be awaited first!");
16740 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
16741 return nativeResponseValue;
16743 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
16745 export function Ping_set_byteslen(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_byteslen(this_ptr, val);
16750 // debug statements here
16752 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
16754 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
16755 if(!isWasmInitialized) {
16756 throw new Error("initializeWasm() must be awaited first!");
16758 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
16759 return nativeResponseValue;
16761 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
16763 export function Ping_clone_ptr(arg: number): number {
16764 if(!isWasmInitialized) {
16765 throw new Error("initializeWasm() must be awaited first!");
16767 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
16768 return nativeResponseValue;
16770 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
16772 export function Ping_clone(orig: number): number {
16773 if(!isWasmInitialized) {
16774 throw new Error("initializeWasm() must be awaited first!");
16776 const nativeResponseValue = wasm.TS_Ping_clone(orig);
16777 return nativeResponseValue;
16779 // void Pong_free(struct LDKPong this_obj);
16781 export function Pong_free(this_obj: number): void {
16782 if(!isWasmInitialized) {
16783 throw new Error("initializeWasm() must be awaited first!");
16785 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
16786 // debug statements here
16788 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
16790 export function Pong_get_byteslen(this_ptr: number): number {
16791 if(!isWasmInitialized) {
16792 throw new Error("initializeWasm() must be awaited first!");
16794 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
16795 return nativeResponseValue;
16797 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
16799 export function Pong_set_byteslen(this_ptr: number, val: number): void {
16800 if(!isWasmInitialized) {
16801 throw new Error("initializeWasm() must be awaited first!");
16803 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
16804 // debug statements here
16806 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
16808 export function Pong_new(byteslen_arg: number): number {
16809 if(!isWasmInitialized) {
16810 throw new Error("initializeWasm() must be awaited first!");
16812 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
16813 return nativeResponseValue;
16815 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
16817 export function Pong_clone_ptr(arg: number): number {
16818 if(!isWasmInitialized) {
16819 throw new Error("initializeWasm() must be awaited first!");
16821 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
16822 return nativeResponseValue;
16824 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
16826 export function Pong_clone(orig: number): number {
16827 if(!isWasmInitialized) {
16828 throw new Error("initializeWasm() must be awaited first!");
16830 const nativeResponseValue = wasm.TS_Pong_clone(orig);
16831 return nativeResponseValue;
16833 // void OpenChannel_free(struct LDKOpenChannel this_obj);
16835 export function OpenChannel_free(this_obj: number): void {
16836 if(!isWasmInitialized) {
16837 throw new Error("initializeWasm() must be awaited first!");
16839 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
16840 // debug statements here
16842 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
16844 export function OpenChannel_get_chain_hash(this_ptr: number): number {
16845 if(!isWasmInitialized) {
16846 throw new Error("initializeWasm() must be awaited first!");
16848 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
16849 return nativeResponseValue;
16851 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16853 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
16854 if(!isWasmInitialized) {
16855 throw new Error("initializeWasm() must be awaited first!");
16857 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
16858 // debug statements here
16860 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
16862 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
16863 if(!isWasmInitialized) {
16864 throw new Error("initializeWasm() must be awaited first!");
16866 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
16867 return nativeResponseValue;
16869 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16871 export function OpenChannel_set_temporary_channel_id(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_temporary_channel_id(this_ptr, val);
16876 // debug statements here
16878 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16880 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
16881 if(!isWasmInitialized) {
16882 throw new Error("initializeWasm() must be awaited first!");
16884 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
16885 return nativeResponseValue;
16887 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16889 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
16890 if(!isWasmInitialized) {
16891 throw new Error("initializeWasm() must be awaited first!");
16893 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
16894 // debug statements here
16896 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16898 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
16899 if(!isWasmInitialized) {
16900 throw new Error("initializeWasm() must be awaited first!");
16902 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
16903 return nativeResponseValue;
16905 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16907 export function OpenChannel_set_push_msat(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_push_msat(this_ptr, val);
16912 // debug statements here
16914 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16916 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
16917 if(!isWasmInitialized) {
16918 throw new Error("initializeWasm() must be awaited first!");
16920 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
16921 return nativeResponseValue;
16923 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16925 export function OpenChannel_set_dust_limit_satoshis(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_dust_limit_satoshis(this_ptr, val);
16930 // debug statements here
16932 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16934 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16935 if(!isWasmInitialized) {
16936 throw new Error("initializeWasm() must be awaited first!");
16938 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
16939 return nativeResponseValue;
16941 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16943 export function OpenChannel_set_max_htlc_value_in_flight_msat(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_max_htlc_value_in_flight_msat(this_ptr, val);
16948 // debug statements here
16950 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16952 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
16953 if(!isWasmInitialized) {
16954 throw new Error("initializeWasm() must be awaited first!");
16956 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
16957 return nativeResponseValue;
16959 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16961 export function OpenChannel_set_channel_reserve_satoshis(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_channel_reserve_satoshis(this_ptr, val);
16966 // debug statements here
16968 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16970 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
16971 if(!isWasmInitialized) {
16972 throw new Error("initializeWasm() must be awaited first!");
16974 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
16975 return nativeResponseValue;
16977 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
16979 export function OpenChannel_set_htlc_minimum_msat(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_htlc_minimum_msat(this_ptr, val);
16984 // debug statements here
16986 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
16988 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
16989 if(!isWasmInitialized) {
16990 throw new Error("initializeWasm() must be awaited first!");
16992 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
16993 return nativeResponseValue;
16995 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
16997 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
16998 if(!isWasmInitialized) {
16999 throw new Error("initializeWasm() must be awaited first!");
17001 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
17002 // debug statements here
17004 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17006 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
17007 if(!isWasmInitialized) {
17008 throw new Error("initializeWasm() must be awaited first!");
17010 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
17011 return nativeResponseValue;
17013 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
17015 export function OpenChannel_set_to_self_delay(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_to_self_delay(this_ptr, val);
17020 // debug statements here
17022 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17024 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
17025 if(!isWasmInitialized) {
17026 throw new Error("initializeWasm() must be awaited first!");
17028 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
17029 return nativeResponseValue;
17031 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
17033 export function OpenChannel_set_max_accepted_htlcs(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_max_accepted_htlcs(this_ptr, val);
17038 // debug statements here
17040 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17042 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
17043 if(!isWasmInitialized) {
17044 throw new Error("initializeWasm() must be awaited first!");
17046 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
17047 return nativeResponseValue;
17049 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17051 export function OpenChannel_set_funding_pubkey(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_funding_pubkey(this_ptr, val);
17056 // debug statements here
17058 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17060 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
17061 if(!isWasmInitialized) {
17062 throw new Error("initializeWasm() must be awaited first!");
17064 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
17065 return nativeResponseValue;
17067 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17069 export function OpenChannel_set_revocation_basepoint(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_revocation_basepoint(this_ptr, val);
17074 // debug statements here
17076 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17078 export function OpenChannel_get_payment_point(this_ptr: number): number {
17079 if(!isWasmInitialized) {
17080 throw new Error("initializeWasm() must be awaited first!");
17082 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
17083 return nativeResponseValue;
17085 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17087 export function OpenChannel_set_payment_point(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_payment_point(this_ptr, val);
17092 // debug statements here
17094 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17096 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
17097 if(!isWasmInitialized) {
17098 throw new Error("initializeWasm() must be awaited first!");
17100 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
17101 return nativeResponseValue;
17103 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17105 export function OpenChannel_set_delayed_payment_basepoint(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_delayed_payment_basepoint(this_ptr, val);
17110 // debug statements here
17112 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17114 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
17115 if(!isWasmInitialized) {
17116 throw new Error("initializeWasm() must be awaited first!");
17118 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
17119 return nativeResponseValue;
17121 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17123 export function OpenChannel_set_htlc_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_htlc_basepoint(this_ptr, val);
17128 // debug statements here
17130 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17132 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
17133 if(!isWasmInitialized) {
17134 throw new Error("initializeWasm() must be awaited first!");
17136 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
17137 return nativeResponseValue;
17139 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17141 export function OpenChannel_set_first_per_commitment_point(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_first_per_commitment_point(this_ptr, val);
17146 // debug statements here
17148 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17150 export function OpenChannel_get_channel_flags(this_ptr: number): number {
17151 if(!isWasmInitialized) {
17152 throw new Error("initializeWasm() must be awaited first!");
17154 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
17155 return nativeResponseValue;
17157 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
17159 export function OpenChannel_set_channel_flags(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_channel_flags(this_ptr, val);
17164 // debug statements here
17166 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
17168 export function OpenChannel_get_channel_type(this_ptr: number): number {
17169 if(!isWasmInitialized) {
17170 throw new Error("initializeWasm() must be awaited first!");
17172 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
17173 return nativeResponseValue;
17175 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
17177 export function OpenChannel_set_channel_type(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_type(this_ptr, val);
17182 // debug statements here
17184 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
17186 export function OpenChannel_clone_ptr(arg: number): number {
17187 if(!isWasmInitialized) {
17188 throw new Error("initializeWasm() must be awaited first!");
17190 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
17191 return nativeResponseValue;
17193 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
17195 export function OpenChannel_clone(orig: number): number {
17196 if(!isWasmInitialized) {
17197 throw new Error("initializeWasm() must be awaited first!");
17199 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
17200 return nativeResponseValue;
17202 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
17204 export function AcceptChannel_free(this_obj: number): void {
17205 if(!isWasmInitialized) {
17206 throw new Error("initializeWasm() must be awaited first!");
17208 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
17209 // debug statements here
17211 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
17213 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
17214 if(!isWasmInitialized) {
17215 throw new Error("initializeWasm() must be awaited first!");
17217 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
17218 return nativeResponseValue;
17220 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17222 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
17223 if(!isWasmInitialized) {
17224 throw new Error("initializeWasm() must be awaited first!");
17226 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
17227 // debug statements here
17229 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17231 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
17232 if(!isWasmInitialized) {
17233 throw new Error("initializeWasm() must be awaited first!");
17235 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
17236 return nativeResponseValue;
17238 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17240 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
17241 if(!isWasmInitialized) {
17242 throw new Error("initializeWasm() must be awaited first!");
17244 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
17245 // debug statements here
17247 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17249 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
17250 if(!isWasmInitialized) {
17251 throw new Error("initializeWasm() must be awaited first!");
17253 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
17254 return nativeResponseValue;
17256 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17258 export function AcceptChannel_set_max_htlc_value_in_flight_msat(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_max_htlc_value_in_flight_msat(this_ptr, val);
17263 // debug statements here
17265 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17267 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
17268 if(!isWasmInitialized) {
17269 throw new Error("initializeWasm() must be awaited first!");
17271 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
17272 return nativeResponseValue;
17274 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17276 export function AcceptChannel_set_channel_reserve_satoshis(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_channel_reserve_satoshis(this_ptr, val);
17281 // debug statements here
17283 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17285 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
17286 if(!isWasmInitialized) {
17287 throw new Error("initializeWasm() must be awaited first!");
17289 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
17290 return nativeResponseValue;
17292 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
17294 export function AcceptChannel_set_htlc_minimum_msat(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_htlc_minimum_msat(this_ptr, val);
17299 // debug statements here
17301 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17303 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
17304 if(!isWasmInitialized) {
17305 throw new Error("initializeWasm() must be awaited first!");
17307 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
17308 return nativeResponseValue;
17310 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
17312 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
17313 if(!isWasmInitialized) {
17314 throw new Error("initializeWasm() must be awaited first!");
17316 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
17317 // debug statements here
17319 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17321 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
17322 if(!isWasmInitialized) {
17323 throw new Error("initializeWasm() must be awaited first!");
17325 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
17326 return nativeResponseValue;
17328 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
17330 export function AcceptChannel_set_to_self_delay(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_to_self_delay(this_ptr, val);
17335 // debug statements here
17337 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17339 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
17340 if(!isWasmInitialized) {
17341 throw new Error("initializeWasm() must be awaited first!");
17343 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
17344 return nativeResponseValue;
17346 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
17348 export function AcceptChannel_set_max_accepted_htlcs(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_max_accepted_htlcs(this_ptr, val);
17353 // debug statements here
17355 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17357 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
17358 if(!isWasmInitialized) {
17359 throw new Error("initializeWasm() must be awaited first!");
17361 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
17362 return nativeResponseValue;
17364 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17366 export function AcceptChannel_set_funding_pubkey(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_funding_pubkey(this_ptr, val);
17371 // debug statements here
17373 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17375 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
17376 if(!isWasmInitialized) {
17377 throw new Error("initializeWasm() must be awaited first!");
17379 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
17380 return nativeResponseValue;
17382 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17384 export function AcceptChannel_set_revocation_basepoint(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_revocation_basepoint(this_ptr, val);
17389 // debug statements here
17391 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17393 export function AcceptChannel_get_payment_point(this_ptr: number): number {
17394 if(!isWasmInitialized) {
17395 throw new Error("initializeWasm() must be awaited first!");
17397 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
17398 return nativeResponseValue;
17400 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17402 export function AcceptChannel_set_payment_point(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_payment_point(this_ptr, val);
17407 // debug statements here
17409 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17411 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
17412 if(!isWasmInitialized) {
17413 throw new Error("initializeWasm() must be awaited first!");
17415 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
17416 return nativeResponseValue;
17418 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17420 export function AcceptChannel_set_delayed_payment_basepoint(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_delayed_payment_basepoint(this_ptr, val);
17425 // debug statements here
17427 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17429 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
17430 if(!isWasmInitialized) {
17431 throw new Error("initializeWasm() must be awaited first!");
17433 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
17434 return nativeResponseValue;
17436 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17438 export function AcceptChannel_set_htlc_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_htlc_basepoint(this_ptr, val);
17443 // debug statements here
17445 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
17447 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
17448 if(!isWasmInitialized) {
17449 throw new Error("initializeWasm() must be awaited first!");
17451 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
17452 return nativeResponseValue;
17454 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17456 export function AcceptChannel_set_first_per_commitment_point(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_first_per_commitment_point(this_ptr, val);
17461 // debug statements here
17463 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
17465 export function AcceptChannel_clone_ptr(arg: number): number {
17466 if(!isWasmInitialized) {
17467 throw new Error("initializeWasm() must be awaited first!");
17469 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
17470 return nativeResponseValue;
17472 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
17474 export function AcceptChannel_clone(orig: number): number {
17475 if(!isWasmInitialized) {
17476 throw new Error("initializeWasm() must be awaited first!");
17478 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
17479 return nativeResponseValue;
17481 // void FundingCreated_free(struct LDKFundingCreated this_obj);
17483 export function FundingCreated_free(this_obj: number): void {
17484 if(!isWasmInitialized) {
17485 throw new Error("initializeWasm() must be awaited first!");
17487 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
17488 // debug statements here
17490 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
17492 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
17493 if(!isWasmInitialized) {
17494 throw new Error("initializeWasm() must be awaited first!");
17496 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
17497 return nativeResponseValue;
17499 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17501 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
17502 if(!isWasmInitialized) {
17503 throw new Error("initializeWasm() must be awaited first!");
17505 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
17506 // debug statements here
17508 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
17510 export function FundingCreated_get_funding_txid(this_ptr: number): number {
17511 if(!isWasmInitialized) {
17512 throw new Error("initializeWasm() must be awaited first!");
17514 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
17515 return nativeResponseValue;
17517 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17519 export function FundingCreated_set_funding_txid(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_funding_txid(this_ptr, val);
17524 // debug statements here
17526 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
17528 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
17529 if(!isWasmInitialized) {
17530 throw new Error("initializeWasm() must be awaited first!");
17532 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
17533 return nativeResponseValue;
17535 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
17537 export function FundingCreated_set_funding_output_index(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_output_index(this_ptr, val);
17542 // debug statements here
17544 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
17546 export function FundingCreated_get_signature(this_ptr: number): number {
17547 if(!isWasmInitialized) {
17548 throw new Error("initializeWasm() must be awaited first!");
17550 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
17551 return nativeResponseValue;
17553 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
17555 export function FundingCreated_set_signature(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_signature(this_ptr, val);
17560 // debug statements here
17562 // 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);
17564 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
17565 if(!isWasmInitialized) {
17566 throw new Error("initializeWasm() must be awaited first!");
17568 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
17569 return nativeResponseValue;
17571 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
17573 export function FundingCreated_clone_ptr(arg: number): number {
17574 if(!isWasmInitialized) {
17575 throw new Error("initializeWasm() must be awaited first!");
17577 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
17578 return nativeResponseValue;
17580 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
17582 export function FundingCreated_clone(orig: number): number {
17583 if(!isWasmInitialized) {
17584 throw new Error("initializeWasm() must be awaited first!");
17586 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
17587 return nativeResponseValue;
17589 // void FundingSigned_free(struct LDKFundingSigned this_obj);
17591 export function FundingSigned_free(this_obj: number): void {
17592 if(!isWasmInitialized) {
17593 throw new Error("initializeWasm() must be awaited first!");
17595 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
17596 // debug statements here
17598 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
17600 export function FundingSigned_get_channel_id(this_ptr: number): number {
17601 if(!isWasmInitialized) {
17602 throw new Error("initializeWasm() must be awaited first!");
17604 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
17605 return nativeResponseValue;
17607 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17609 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
17610 if(!isWasmInitialized) {
17611 throw new Error("initializeWasm() must be awaited first!");
17613 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
17614 // debug statements here
17616 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
17618 export function FundingSigned_get_signature(this_ptr: number): number {
17619 if(!isWasmInitialized) {
17620 throw new Error("initializeWasm() must be awaited first!");
17622 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
17623 return nativeResponseValue;
17625 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
17627 export function FundingSigned_set_signature(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_signature(this_ptr, val);
17632 // debug statements here
17634 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
17636 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
17637 if(!isWasmInitialized) {
17638 throw new Error("initializeWasm() must be awaited first!");
17640 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
17641 return nativeResponseValue;
17643 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
17645 export function FundingSigned_clone_ptr(arg: number): number {
17646 if(!isWasmInitialized) {
17647 throw new Error("initializeWasm() must be awaited first!");
17649 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
17650 return nativeResponseValue;
17652 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
17654 export function FundingSigned_clone(orig: number): number {
17655 if(!isWasmInitialized) {
17656 throw new Error("initializeWasm() must be awaited first!");
17658 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
17659 return nativeResponseValue;
17661 // void FundingLocked_free(struct LDKFundingLocked this_obj);
17663 export function FundingLocked_free(this_obj: number): void {
17664 if(!isWasmInitialized) {
17665 throw new Error("initializeWasm() must be awaited first!");
17667 const nativeResponseValue = wasm.TS_FundingLocked_free(this_obj);
17668 // debug statements here
17670 // const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
17672 export function FundingLocked_get_channel_id(this_ptr: number): number {
17673 if(!isWasmInitialized) {
17674 throw new Error("initializeWasm() must be awaited first!");
17676 const nativeResponseValue = wasm.TS_FundingLocked_get_channel_id(this_ptr);
17677 return nativeResponseValue;
17679 // void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17681 export function FundingLocked_set_channel_id(this_ptr: number, val: number): void {
17682 if(!isWasmInitialized) {
17683 throw new Error("initializeWasm() must be awaited first!");
17685 const nativeResponseValue = wasm.TS_FundingLocked_set_channel_id(this_ptr, val);
17686 // debug statements here
17688 // struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
17690 export function FundingLocked_get_next_per_commitment_point(this_ptr: number): number {
17691 if(!isWasmInitialized) {
17692 throw new Error("initializeWasm() must be awaited first!");
17694 const nativeResponseValue = wasm.TS_FundingLocked_get_next_per_commitment_point(this_ptr);
17695 return nativeResponseValue;
17697 // void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17699 export function FundingLocked_set_next_per_commitment_point(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_next_per_commitment_point(this_ptr, val);
17704 // debug statements here
17706 // MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg);
17708 export function FundingLocked_new(channel_id_arg: number, next_per_commitment_point_arg: number): number {
17709 if(!isWasmInitialized) {
17710 throw new Error("initializeWasm() must be awaited first!");
17712 const nativeResponseValue = wasm.TS_FundingLocked_new(channel_id_arg, next_per_commitment_point_arg);
17713 return nativeResponseValue;
17715 // uintptr_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
17717 export function FundingLocked_clone_ptr(arg: number): number {
17718 if(!isWasmInitialized) {
17719 throw new Error("initializeWasm() must be awaited first!");
17721 const nativeResponseValue = wasm.TS_FundingLocked_clone_ptr(arg);
17722 return nativeResponseValue;
17724 // struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
17726 export function FundingLocked_clone(orig: number): number {
17727 if(!isWasmInitialized) {
17728 throw new Error("initializeWasm() must be awaited first!");
17730 const nativeResponseValue = wasm.TS_FundingLocked_clone(orig);
17731 return nativeResponseValue;
17733 // void Shutdown_free(struct LDKShutdown this_obj);
17735 export function Shutdown_free(this_obj: number): void {
17736 if(!isWasmInitialized) {
17737 throw new Error("initializeWasm() must be awaited first!");
17739 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
17740 // debug statements here
17742 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
17744 export function Shutdown_get_channel_id(this_ptr: number): number {
17745 if(!isWasmInitialized) {
17746 throw new Error("initializeWasm() must be awaited first!");
17748 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
17749 return nativeResponseValue;
17751 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17753 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
17754 if(!isWasmInitialized) {
17755 throw new Error("initializeWasm() must be awaited first!");
17757 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
17758 // debug statements here
17760 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
17762 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
17763 if(!isWasmInitialized) {
17764 throw new Error("initializeWasm() must be awaited first!");
17766 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
17767 return nativeResponseValue;
17769 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17771 export function Shutdown_set_scriptpubkey(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_scriptpubkey(this_ptr, val);
17776 // debug statements here
17778 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
17780 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
17781 if(!isWasmInitialized) {
17782 throw new Error("initializeWasm() must be awaited first!");
17784 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
17785 return nativeResponseValue;
17787 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
17789 export function Shutdown_clone_ptr(arg: number): number {
17790 if(!isWasmInitialized) {
17791 throw new Error("initializeWasm() must be awaited first!");
17793 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
17794 return nativeResponseValue;
17796 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
17798 export function Shutdown_clone(orig: number): number {
17799 if(!isWasmInitialized) {
17800 throw new Error("initializeWasm() must be awaited first!");
17802 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
17803 return nativeResponseValue;
17805 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
17807 export function ClosingSignedFeeRange_free(this_obj: number): void {
17808 if(!isWasmInitialized) {
17809 throw new Error("initializeWasm() must be awaited first!");
17811 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
17812 // debug statements here
17814 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
17816 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
17817 if(!isWasmInitialized) {
17818 throw new Error("initializeWasm() must be awaited first!");
17820 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
17821 return nativeResponseValue;
17823 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
17825 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
17826 if(!isWasmInitialized) {
17827 throw new Error("initializeWasm() must be awaited first!");
17829 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
17830 // debug statements here
17832 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
17834 export function ClosingSignedFeeRange_get_max_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_max_fee_satoshis(this_ptr);
17839 return nativeResponseValue;
17841 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
17843 export function ClosingSignedFeeRange_set_max_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_max_fee_satoshis(this_ptr, val);
17848 // debug statements here
17850 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
17852 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
17853 if(!isWasmInitialized) {
17854 throw new Error("initializeWasm() must be awaited first!");
17856 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
17857 return nativeResponseValue;
17859 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
17861 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
17862 if(!isWasmInitialized) {
17863 throw new Error("initializeWasm() must be awaited first!");
17865 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
17866 return nativeResponseValue;
17868 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
17870 export function ClosingSignedFeeRange_clone(orig: number): number {
17871 if(!isWasmInitialized) {
17872 throw new Error("initializeWasm() must be awaited first!");
17874 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
17875 return nativeResponseValue;
17877 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
17879 export function ClosingSigned_free(this_obj: number): void {
17880 if(!isWasmInitialized) {
17881 throw new Error("initializeWasm() must be awaited first!");
17883 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
17884 // debug statements here
17886 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
17888 export function ClosingSigned_get_channel_id(this_ptr: number): number {
17889 if(!isWasmInitialized) {
17890 throw new Error("initializeWasm() must be awaited first!");
17892 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
17893 return nativeResponseValue;
17895 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17897 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
17898 if(!isWasmInitialized) {
17899 throw new Error("initializeWasm() must be awaited first!");
17901 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
17902 // debug statements here
17904 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
17906 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
17907 if(!isWasmInitialized) {
17908 throw new Error("initializeWasm() must be awaited first!");
17910 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
17911 return nativeResponseValue;
17913 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
17915 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
17916 if(!isWasmInitialized) {
17917 throw new Error("initializeWasm() must be awaited first!");
17919 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
17920 // debug statements here
17922 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
17924 export function ClosingSigned_get_signature(this_ptr: number): number {
17925 if(!isWasmInitialized) {
17926 throw new Error("initializeWasm() must be awaited first!");
17928 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
17929 return nativeResponseValue;
17931 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
17933 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
17934 if(!isWasmInitialized) {
17935 throw new Error("initializeWasm() must be awaited first!");
17937 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
17938 // debug statements here
17940 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
17942 export function ClosingSigned_get_fee_range(this_ptr: number): number {
17943 if(!isWasmInitialized) {
17944 throw new Error("initializeWasm() must be awaited first!");
17946 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
17947 return nativeResponseValue;
17949 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
17951 export function ClosingSigned_set_fee_range(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_fee_range(this_ptr, val);
17956 // debug statements here
17958 // 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);
17960 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
17961 if(!isWasmInitialized) {
17962 throw new Error("initializeWasm() must be awaited first!");
17964 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
17965 return nativeResponseValue;
17967 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
17969 export function ClosingSigned_clone_ptr(arg: number): number {
17970 if(!isWasmInitialized) {
17971 throw new Error("initializeWasm() must be awaited first!");
17973 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
17974 return nativeResponseValue;
17976 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
17978 export function ClosingSigned_clone(orig: number): number {
17979 if(!isWasmInitialized) {
17980 throw new Error("initializeWasm() must be awaited first!");
17982 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
17983 return nativeResponseValue;
17985 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
17987 export function UpdateAddHTLC_free(this_obj: number): void {
17988 if(!isWasmInitialized) {
17989 throw new Error("initializeWasm() must be awaited first!");
17991 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
17992 // debug statements here
17994 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
17996 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
17997 if(!isWasmInitialized) {
17998 throw new Error("initializeWasm() must be awaited first!");
18000 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
18001 return nativeResponseValue;
18003 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18005 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
18006 if(!isWasmInitialized) {
18007 throw new Error("initializeWasm() must be awaited first!");
18009 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
18010 // debug statements here
18012 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
18014 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
18015 if(!isWasmInitialized) {
18016 throw new Error("initializeWasm() must be awaited first!");
18018 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
18019 return nativeResponseValue;
18021 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
18023 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18024 if(!isWasmInitialized) {
18025 throw new Error("initializeWasm() must be awaited first!");
18027 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
18028 // debug statements here
18030 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
18032 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
18033 if(!isWasmInitialized) {
18034 throw new Error("initializeWasm() must be awaited first!");
18036 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
18037 return nativeResponseValue;
18039 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
18041 export function UpdateAddHTLC_set_amount_msat(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_amount_msat(this_ptr, val);
18046 // debug statements here
18048 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
18050 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
18051 if(!isWasmInitialized) {
18052 throw new Error("initializeWasm() must be awaited first!");
18054 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
18055 return nativeResponseValue;
18057 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18059 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
18060 if(!isWasmInitialized) {
18061 throw new Error("initializeWasm() must be awaited first!");
18063 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
18064 // debug statements here
18066 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
18068 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
18069 if(!isWasmInitialized) {
18070 throw new Error("initializeWasm() must be awaited first!");
18072 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
18073 return nativeResponseValue;
18075 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
18077 export function UpdateAddHTLC_set_cltv_expiry(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_cltv_expiry(this_ptr, val);
18082 // debug statements here
18084 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
18086 export function UpdateAddHTLC_clone_ptr(arg: number): number {
18087 if(!isWasmInitialized) {
18088 throw new Error("initializeWasm() must be awaited first!");
18090 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
18091 return nativeResponseValue;
18093 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
18095 export function UpdateAddHTLC_clone(orig: number): number {
18096 if(!isWasmInitialized) {
18097 throw new Error("initializeWasm() must be awaited first!");
18099 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
18100 return nativeResponseValue;
18102 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
18104 export function UpdateFulfillHTLC_free(this_obj: number): void {
18105 if(!isWasmInitialized) {
18106 throw new Error("initializeWasm() must be awaited first!");
18108 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
18109 // debug statements here
18111 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
18113 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
18114 if(!isWasmInitialized) {
18115 throw new Error("initializeWasm() must be awaited first!");
18117 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
18118 return nativeResponseValue;
18120 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18122 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
18123 if(!isWasmInitialized) {
18124 throw new Error("initializeWasm() must be awaited first!");
18126 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
18127 // debug statements here
18129 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
18131 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
18132 if(!isWasmInitialized) {
18133 throw new Error("initializeWasm() must be awaited first!");
18135 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
18136 return nativeResponseValue;
18138 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
18140 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18141 if(!isWasmInitialized) {
18142 throw new Error("initializeWasm() must be awaited first!");
18144 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
18145 // debug statements here
18147 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
18149 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
18150 if(!isWasmInitialized) {
18151 throw new Error("initializeWasm() must be awaited first!");
18153 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
18154 return nativeResponseValue;
18156 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18158 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
18159 if(!isWasmInitialized) {
18160 throw new Error("initializeWasm() must be awaited first!");
18162 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
18163 // debug statements here
18165 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
18167 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
18168 if(!isWasmInitialized) {
18169 throw new Error("initializeWasm() must be awaited first!");
18171 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
18172 return nativeResponseValue;
18174 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
18176 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
18177 if(!isWasmInitialized) {
18178 throw new Error("initializeWasm() must be awaited first!");
18180 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
18181 return nativeResponseValue;
18183 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
18185 export function UpdateFulfillHTLC_clone(orig: number): number {
18186 if(!isWasmInitialized) {
18187 throw new Error("initializeWasm() must be awaited first!");
18189 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
18190 return nativeResponseValue;
18192 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
18194 export function UpdateFailHTLC_free(this_obj: number): void {
18195 if(!isWasmInitialized) {
18196 throw new Error("initializeWasm() must be awaited first!");
18198 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
18199 // debug statements here
18201 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
18203 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
18204 if(!isWasmInitialized) {
18205 throw new Error("initializeWasm() must be awaited first!");
18207 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
18208 return nativeResponseValue;
18210 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18212 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
18213 if(!isWasmInitialized) {
18214 throw new Error("initializeWasm() must be awaited first!");
18216 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
18217 // debug statements here
18219 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
18221 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
18222 if(!isWasmInitialized) {
18223 throw new Error("initializeWasm() must be awaited first!");
18225 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
18226 return nativeResponseValue;
18228 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
18230 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18231 if(!isWasmInitialized) {
18232 throw new Error("initializeWasm() must be awaited first!");
18234 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
18235 // debug statements here
18237 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
18239 export function UpdateFailHTLC_clone_ptr(arg: number): number {
18240 if(!isWasmInitialized) {
18241 throw new Error("initializeWasm() must be awaited first!");
18243 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
18244 return nativeResponseValue;
18246 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
18248 export function UpdateFailHTLC_clone(orig: number): number {
18249 if(!isWasmInitialized) {
18250 throw new Error("initializeWasm() must be awaited first!");
18252 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
18253 return nativeResponseValue;
18255 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
18257 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
18258 if(!isWasmInitialized) {
18259 throw new Error("initializeWasm() must be awaited first!");
18261 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
18262 // debug statements here
18264 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
18266 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
18267 if(!isWasmInitialized) {
18268 throw new Error("initializeWasm() must be awaited first!");
18270 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
18271 return nativeResponseValue;
18273 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18275 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
18276 if(!isWasmInitialized) {
18277 throw new Error("initializeWasm() must be awaited first!");
18279 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
18280 // debug statements here
18282 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
18284 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
18285 if(!isWasmInitialized) {
18286 throw new Error("initializeWasm() must be awaited first!");
18288 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
18289 return nativeResponseValue;
18291 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
18293 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
18294 if(!isWasmInitialized) {
18295 throw new Error("initializeWasm() must be awaited first!");
18297 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
18298 // debug statements here
18300 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
18302 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
18303 if(!isWasmInitialized) {
18304 throw new Error("initializeWasm() must be awaited first!");
18306 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
18307 return nativeResponseValue;
18309 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
18311 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
18312 if(!isWasmInitialized) {
18313 throw new Error("initializeWasm() must be awaited first!");
18315 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
18316 // debug statements here
18318 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
18320 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
18321 if(!isWasmInitialized) {
18322 throw new Error("initializeWasm() must be awaited first!");
18324 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
18325 return nativeResponseValue;
18327 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
18329 export function UpdateFailMalformedHTLC_clone(orig: number): number {
18330 if(!isWasmInitialized) {
18331 throw new Error("initializeWasm() must be awaited first!");
18333 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
18334 return nativeResponseValue;
18336 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
18338 export function CommitmentSigned_free(this_obj: number): void {
18339 if(!isWasmInitialized) {
18340 throw new Error("initializeWasm() must be awaited first!");
18342 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
18343 // debug statements here
18345 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
18347 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
18348 if(!isWasmInitialized) {
18349 throw new Error("initializeWasm() must be awaited first!");
18351 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
18352 return nativeResponseValue;
18354 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18356 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
18357 if(!isWasmInitialized) {
18358 throw new Error("initializeWasm() must be awaited first!");
18360 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
18361 // debug statements here
18363 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
18365 export function CommitmentSigned_get_signature(this_ptr: number): number {
18366 if(!isWasmInitialized) {
18367 throw new Error("initializeWasm() must be awaited first!");
18369 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
18370 return nativeResponseValue;
18372 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
18374 export function CommitmentSigned_set_signature(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_signature(this_ptr, val);
18379 // debug statements here
18381 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
18383 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
18384 if(!isWasmInitialized) {
18385 throw new Error("initializeWasm() must be awaited first!");
18387 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
18388 // debug statements here
18390 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
18392 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
18393 if(!isWasmInitialized) {
18394 throw new Error("initializeWasm() must be awaited first!");
18396 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
18397 return nativeResponseValue;
18399 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
18401 export function CommitmentSigned_clone_ptr(arg: number): number {
18402 if(!isWasmInitialized) {
18403 throw new Error("initializeWasm() must be awaited first!");
18405 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
18406 return nativeResponseValue;
18408 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
18410 export function CommitmentSigned_clone(orig: number): number {
18411 if(!isWasmInitialized) {
18412 throw new Error("initializeWasm() must be awaited first!");
18414 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
18415 return nativeResponseValue;
18417 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
18419 export function RevokeAndACK_free(this_obj: number): void {
18420 if(!isWasmInitialized) {
18421 throw new Error("initializeWasm() must be awaited first!");
18423 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
18424 // debug statements here
18426 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
18428 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
18429 if(!isWasmInitialized) {
18430 throw new Error("initializeWasm() must be awaited first!");
18432 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
18433 return nativeResponseValue;
18435 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18437 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
18438 if(!isWasmInitialized) {
18439 throw new Error("initializeWasm() must be awaited first!");
18441 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
18442 // debug statements here
18444 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
18446 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
18447 if(!isWasmInitialized) {
18448 throw new Error("initializeWasm() must be awaited first!");
18450 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
18451 return nativeResponseValue;
18453 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18455 export function RevokeAndACK_set_per_commitment_secret(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_per_commitment_secret(this_ptr, val);
18460 // debug statements here
18462 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
18464 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
18465 if(!isWasmInitialized) {
18466 throw new Error("initializeWasm() must be awaited first!");
18468 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
18469 return nativeResponseValue;
18471 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18473 export function RevokeAndACK_set_next_per_commitment_point(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_next_per_commitment_point(this_ptr, val);
18478 // debug statements here
18480 // 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);
18482 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
18483 if(!isWasmInitialized) {
18484 throw new Error("initializeWasm() must be awaited first!");
18486 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
18487 return nativeResponseValue;
18489 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
18491 export function RevokeAndACK_clone_ptr(arg: number): number {
18492 if(!isWasmInitialized) {
18493 throw new Error("initializeWasm() must be awaited first!");
18495 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
18496 return nativeResponseValue;
18498 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
18500 export function RevokeAndACK_clone(orig: number): number {
18501 if(!isWasmInitialized) {
18502 throw new Error("initializeWasm() must be awaited first!");
18504 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
18505 return nativeResponseValue;
18507 // void UpdateFee_free(struct LDKUpdateFee this_obj);
18509 export function UpdateFee_free(this_obj: number): void {
18510 if(!isWasmInitialized) {
18511 throw new Error("initializeWasm() must be awaited first!");
18513 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
18514 // debug statements here
18516 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
18518 export function UpdateFee_get_channel_id(this_ptr: number): number {
18519 if(!isWasmInitialized) {
18520 throw new Error("initializeWasm() must be awaited first!");
18522 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
18523 return nativeResponseValue;
18525 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18527 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
18528 if(!isWasmInitialized) {
18529 throw new Error("initializeWasm() must be awaited first!");
18531 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
18532 // debug statements here
18534 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
18536 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
18537 if(!isWasmInitialized) {
18538 throw new Error("initializeWasm() must be awaited first!");
18540 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
18541 return nativeResponseValue;
18543 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
18545 export function UpdateFee_set_feerate_per_kw(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_feerate_per_kw(this_ptr, val);
18550 // debug statements here
18552 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
18554 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
18555 if(!isWasmInitialized) {
18556 throw new Error("initializeWasm() must be awaited first!");
18558 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
18559 return nativeResponseValue;
18561 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
18563 export function UpdateFee_clone_ptr(arg: number): number {
18564 if(!isWasmInitialized) {
18565 throw new Error("initializeWasm() must be awaited first!");
18567 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
18568 return nativeResponseValue;
18570 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
18572 export function UpdateFee_clone(orig: number): number {
18573 if(!isWasmInitialized) {
18574 throw new Error("initializeWasm() must be awaited first!");
18576 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
18577 return nativeResponseValue;
18579 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
18581 export function DataLossProtect_free(this_obj: number): void {
18582 if(!isWasmInitialized) {
18583 throw new Error("initializeWasm() must be awaited first!");
18585 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
18586 // debug statements here
18588 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
18590 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
18591 if(!isWasmInitialized) {
18592 throw new Error("initializeWasm() must be awaited first!");
18594 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
18595 return nativeResponseValue;
18597 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18599 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
18600 if(!isWasmInitialized) {
18601 throw new Error("initializeWasm() must be awaited first!");
18603 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
18604 // debug statements here
18606 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
18608 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
18609 if(!isWasmInitialized) {
18610 throw new Error("initializeWasm() must be awaited first!");
18612 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
18613 return nativeResponseValue;
18615 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18617 export function DataLossProtect_set_my_current_per_commitment_point(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_my_current_per_commitment_point(this_ptr, val);
18622 // debug statements here
18624 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
18626 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
18627 if(!isWasmInitialized) {
18628 throw new Error("initializeWasm() must be awaited first!");
18630 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
18631 return nativeResponseValue;
18633 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
18635 export function DataLossProtect_clone_ptr(arg: number): number {
18636 if(!isWasmInitialized) {
18637 throw new Error("initializeWasm() must be awaited first!");
18639 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
18640 return nativeResponseValue;
18642 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
18644 export function DataLossProtect_clone(orig: number): number {
18645 if(!isWasmInitialized) {
18646 throw new Error("initializeWasm() must be awaited first!");
18648 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
18649 return nativeResponseValue;
18651 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
18653 export function ChannelReestablish_free(this_obj: number): void {
18654 if(!isWasmInitialized) {
18655 throw new Error("initializeWasm() must be awaited first!");
18657 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
18658 // debug statements here
18660 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
18662 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
18663 if(!isWasmInitialized) {
18664 throw new Error("initializeWasm() must be awaited first!");
18666 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
18667 return nativeResponseValue;
18669 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18671 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
18672 if(!isWasmInitialized) {
18673 throw new Error("initializeWasm() must be awaited first!");
18675 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
18676 // debug statements here
18678 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
18680 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
18681 if(!isWasmInitialized) {
18682 throw new Error("initializeWasm() must be awaited first!");
18684 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
18685 return nativeResponseValue;
18687 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
18689 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
18690 if(!isWasmInitialized) {
18691 throw new Error("initializeWasm() must be awaited first!");
18693 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
18694 // debug statements here
18696 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
18698 export function ChannelReestablish_get_next_remote_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_remote_commitment_number(this_ptr);
18703 return nativeResponseValue;
18705 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
18707 export function ChannelReestablish_set_next_remote_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_remote_commitment_number(this_ptr, val);
18712 // debug statements here
18714 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
18716 export function ChannelReestablish_clone_ptr(arg: number): number {
18717 if(!isWasmInitialized) {
18718 throw new Error("initializeWasm() must be awaited first!");
18720 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
18721 return nativeResponseValue;
18723 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
18725 export function ChannelReestablish_clone(orig: number): number {
18726 if(!isWasmInitialized) {
18727 throw new Error("initializeWasm() must be awaited first!");
18729 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
18730 return nativeResponseValue;
18732 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
18734 export function AnnouncementSignatures_free(this_obj: number): void {
18735 if(!isWasmInitialized) {
18736 throw new Error("initializeWasm() must be awaited first!");
18738 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
18739 // debug statements here
18741 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
18743 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
18744 if(!isWasmInitialized) {
18745 throw new Error("initializeWasm() must be awaited first!");
18747 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
18748 return nativeResponseValue;
18750 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18752 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
18753 if(!isWasmInitialized) {
18754 throw new Error("initializeWasm() must be awaited first!");
18756 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
18757 // debug statements here
18759 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
18761 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
18762 if(!isWasmInitialized) {
18763 throw new Error("initializeWasm() must be awaited first!");
18765 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
18766 return nativeResponseValue;
18768 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
18770 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
18771 if(!isWasmInitialized) {
18772 throw new Error("initializeWasm() must be awaited first!");
18774 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
18775 // debug statements here
18777 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
18779 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
18780 if(!isWasmInitialized) {
18781 throw new Error("initializeWasm() must be awaited first!");
18783 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
18784 return nativeResponseValue;
18786 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
18788 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
18789 if(!isWasmInitialized) {
18790 throw new Error("initializeWasm() must be awaited first!");
18792 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
18793 // debug statements here
18795 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
18797 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
18798 if(!isWasmInitialized) {
18799 throw new Error("initializeWasm() must be awaited first!");
18801 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
18802 return nativeResponseValue;
18804 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
18806 export function AnnouncementSignatures_set_bitcoin_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_bitcoin_signature(this_ptr, val);
18811 // debug statements here
18813 // 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);
18815 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
18816 if(!isWasmInitialized) {
18817 throw new Error("initializeWasm() must be awaited first!");
18819 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
18820 return nativeResponseValue;
18822 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
18824 export function AnnouncementSignatures_clone_ptr(arg: number): number {
18825 if(!isWasmInitialized) {
18826 throw new Error("initializeWasm() must be awaited first!");
18828 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
18829 return nativeResponseValue;
18831 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
18833 export function AnnouncementSignatures_clone(orig: number): number {
18834 if(!isWasmInitialized) {
18835 throw new Error("initializeWasm() must be awaited first!");
18837 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
18838 return nativeResponseValue;
18840 // void NetAddress_free(struct LDKNetAddress this_ptr);
18842 export function NetAddress_free(this_ptr: number): void {
18843 if(!isWasmInitialized) {
18844 throw new Error("initializeWasm() must be awaited first!");
18846 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
18847 // debug statements here
18849 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
18851 export function NetAddress_clone_ptr(arg: number): number {
18852 if(!isWasmInitialized) {
18853 throw new Error("initializeWasm() must be awaited first!");
18855 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
18856 return nativeResponseValue;
18858 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
18860 export function NetAddress_clone(orig: number): number {
18861 if(!isWasmInitialized) {
18862 throw new Error("initializeWasm() must be awaited first!");
18864 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
18865 return nativeResponseValue;
18867 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
18869 export function NetAddress_ipv4(addr: number, port: number): number {
18870 if(!isWasmInitialized) {
18871 throw new Error("initializeWasm() must be awaited first!");
18873 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
18874 return nativeResponseValue;
18876 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
18878 export function NetAddress_ipv6(addr: number, port: number): number {
18879 if(!isWasmInitialized) {
18880 throw new Error("initializeWasm() must be awaited first!");
18882 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
18883 return nativeResponseValue;
18885 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
18887 export function NetAddress_onion_v2(a: number): number {
18888 if(!isWasmInitialized) {
18889 throw new Error("initializeWasm() must be awaited first!");
18891 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
18892 return nativeResponseValue;
18894 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
18896 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
18897 if(!isWasmInitialized) {
18898 throw new Error("initializeWasm() must be awaited first!");
18900 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
18901 return nativeResponseValue;
18903 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
18905 export function NetAddress_write(obj: number): number {
18906 if(!isWasmInitialized) {
18907 throw new Error("initializeWasm() must be awaited first!");
18909 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
18910 return nativeResponseValue;
18912 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
18914 export function NetAddress_read(ser: number): number {
18915 if(!isWasmInitialized) {
18916 throw new Error("initializeWasm() must be awaited first!");
18918 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
18919 return nativeResponseValue;
18921 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
18923 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
18924 if(!isWasmInitialized) {
18925 throw new Error("initializeWasm() must be awaited first!");
18927 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
18928 // debug statements here
18930 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
18932 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
18933 if(!isWasmInitialized) {
18934 throw new Error("initializeWasm() must be awaited first!");
18936 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
18937 return nativeResponseValue;
18939 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
18941 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
18942 if(!isWasmInitialized) {
18943 throw new Error("initializeWasm() must be awaited first!");
18945 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
18946 // debug statements here
18948 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
18950 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
18951 if(!isWasmInitialized) {
18952 throw new Error("initializeWasm() must be awaited first!");
18954 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
18955 return nativeResponseValue;
18957 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
18959 export function UnsignedNodeAnnouncement_set_timestamp(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_timestamp(this_ptr, val);
18964 // debug statements here
18966 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
18968 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
18969 if(!isWasmInitialized) {
18970 throw new Error("initializeWasm() must be awaited first!");
18972 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
18973 return nativeResponseValue;
18975 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18977 export function UnsignedNodeAnnouncement_set_node_id(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_node_id(this_ptr, val);
18982 // debug statements here
18984 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
18986 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
18987 if(!isWasmInitialized) {
18988 throw new Error("initializeWasm() must be awaited first!");
18990 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
18991 return nativeResponseValue;
18993 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
18995 export function UnsignedNodeAnnouncement_set_rgb(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_rgb(this_ptr, val);
19000 // debug statements here
19002 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
19004 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
19005 if(!isWasmInitialized) {
19006 throw new Error("initializeWasm() must be awaited first!");
19008 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
19009 return nativeResponseValue;
19011 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19013 export function UnsignedNodeAnnouncement_set_alias(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_alias(this_ptr, val);
19018 // debug statements here
19020 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
19022 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
19023 if(!isWasmInitialized) {
19024 throw new Error("initializeWasm() must be awaited first!");
19026 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
19027 // debug statements here
19029 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
19031 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
19032 if(!isWasmInitialized) {
19033 throw new Error("initializeWasm() must be awaited first!");
19035 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
19036 return nativeResponseValue;
19038 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
19040 export function UnsignedNodeAnnouncement_clone(orig: number): number {
19041 if(!isWasmInitialized) {
19042 throw new Error("initializeWasm() must be awaited first!");
19044 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
19045 return nativeResponseValue;
19047 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
19049 export function NodeAnnouncement_free(this_obj: number): void {
19050 if(!isWasmInitialized) {
19051 throw new Error("initializeWasm() must be awaited first!");
19053 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
19054 // debug statements here
19056 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
19058 export function NodeAnnouncement_get_signature(this_ptr: number): number {
19059 if(!isWasmInitialized) {
19060 throw new Error("initializeWasm() must be awaited first!");
19062 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
19063 return nativeResponseValue;
19065 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19067 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
19068 if(!isWasmInitialized) {
19069 throw new Error("initializeWasm() must be awaited first!");
19071 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
19072 // debug statements here
19074 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
19076 export function NodeAnnouncement_get_contents(this_ptr: number): number {
19077 if(!isWasmInitialized) {
19078 throw new Error("initializeWasm() must be awaited first!");
19080 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
19081 return nativeResponseValue;
19083 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
19085 export function NodeAnnouncement_set_contents(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_contents(this_ptr, val);
19090 // debug statements here
19092 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
19094 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
19095 if(!isWasmInitialized) {
19096 throw new Error("initializeWasm() must be awaited first!");
19098 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
19099 return nativeResponseValue;
19101 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
19103 export function NodeAnnouncement_clone_ptr(arg: number): number {
19104 if(!isWasmInitialized) {
19105 throw new Error("initializeWasm() must be awaited first!");
19107 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
19108 return nativeResponseValue;
19110 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
19112 export function NodeAnnouncement_clone(orig: number): number {
19113 if(!isWasmInitialized) {
19114 throw new Error("initializeWasm() must be awaited first!");
19116 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
19117 return nativeResponseValue;
19119 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
19121 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
19122 if(!isWasmInitialized) {
19123 throw new Error("initializeWasm() must be awaited first!");
19125 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
19126 // debug statements here
19128 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19130 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
19131 if(!isWasmInitialized) {
19132 throw new Error("initializeWasm() must be awaited first!");
19134 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
19135 return nativeResponseValue;
19137 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
19139 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
19140 if(!isWasmInitialized) {
19141 throw new Error("initializeWasm() must be awaited first!");
19143 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
19144 // debug statements here
19146 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
19148 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
19149 if(!isWasmInitialized) {
19150 throw new Error("initializeWasm() must be awaited first!");
19152 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
19153 return nativeResponseValue;
19155 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19157 export function UnsignedChannelAnnouncement_set_chain_hash(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_chain_hash(this_ptr, val);
19162 // debug statements here
19164 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19166 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
19167 if(!isWasmInitialized) {
19168 throw new Error("initializeWasm() must be awaited first!");
19170 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
19171 return nativeResponseValue;
19173 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
19175 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
19176 if(!isWasmInitialized) {
19177 throw new Error("initializeWasm() must be awaited first!");
19179 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
19180 // debug statements here
19182 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19184 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
19185 if(!isWasmInitialized) {
19186 throw new Error("initializeWasm() must be awaited first!");
19188 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
19189 return nativeResponseValue;
19191 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19193 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
19194 if(!isWasmInitialized) {
19195 throw new Error("initializeWasm() must be awaited first!");
19197 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
19198 // debug statements here
19200 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19202 export function UnsignedChannelAnnouncement_get_node_id_2(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_2(this_ptr);
19207 return nativeResponseValue;
19209 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19211 export function UnsignedChannelAnnouncement_set_node_id_2(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_2(this_ptr, val);
19216 // debug statements here
19218 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19220 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
19221 if(!isWasmInitialized) {
19222 throw new Error("initializeWasm() must be awaited first!");
19224 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
19225 return nativeResponseValue;
19227 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19229 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(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_bitcoin_key_1(this_ptr, val);
19234 // debug statements here
19236 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
19238 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(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_2(this_ptr);
19243 return nativeResponseValue;
19245 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19247 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(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_2(this_ptr, val);
19252 // debug statements here
19254 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
19256 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
19257 if(!isWasmInitialized) {
19258 throw new Error("initializeWasm() must be awaited first!");
19260 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
19261 return nativeResponseValue;
19263 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
19265 export function UnsignedChannelAnnouncement_clone(orig: number): number {
19266 if(!isWasmInitialized) {
19267 throw new Error("initializeWasm() must be awaited first!");
19269 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
19270 return nativeResponseValue;
19272 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
19274 export function ChannelAnnouncement_free(this_obj: number): void {
19275 if(!isWasmInitialized) {
19276 throw new Error("initializeWasm() must be awaited first!");
19278 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
19279 // debug statements here
19281 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19283 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
19284 if(!isWasmInitialized) {
19285 throw new Error("initializeWasm() must be awaited first!");
19287 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
19288 return nativeResponseValue;
19290 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19292 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
19293 if(!isWasmInitialized) {
19294 throw new Error("initializeWasm() must be awaited first!");
19296 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
19297 // debug statements here
19299 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19301 export function ChannelAnnouncement_get_node_signature_2(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_2(this_ptr);
19306 return nativeResponseValue;
19308 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19310 export function ChannelAnnouncement_set_node_signature_2(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_2(this_ptr, val);
19315 // debug statements here
19317 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19319 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
19320 if(!isWasmInitialized) {
19321 throw new Error("initializeWasm() must be awaited first!");
19323 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
19324 return nativeResponseValue;
19326 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19328 export function ChannelAnnouncement_set_bitcoin_signature_1(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_bitcoin_signature_1(this_ptr, val);
19333 // debug statements here
19335 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19337 export function ChannelAnnouncement_get_bitcoin_signature_2(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_2(this_ptr);
19342 return nativeResponseValue;
19344 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
19346 export function ChannelAnnouncement_set_bitcoin_signature_2(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_2(this_ptr, val);
19351 // debug statements here
19353 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
19355 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
19356 if(!isWasmInitialized) {
19357 throw new Error("initializeWasm() must be awaited first!");
19359 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
19360 return nativeResponseValue;
19362 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
19364 export function ChannelAnnouncement_set_contents(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_contents(this_ptr, val);
19369 // debug statements here
19371 // 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);
19373 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 {
19374 if(!isWasmInitialized) {
19375 throw new Error("initializeWasm() must be awaited first!");
19377 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
19378 return nativeResponseValue;
19380 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
19382 export function ChannelAnnouncement_clone_ptr(arg: number): number {
19383 if(!isWasmInitialized) {
19384 throw new Error("initializeWasm() must be awaited first!");
19386 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
19387 return nativeResponseValue;
19389 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
19391 export function ChannelAnnouncement_clone(orig: number): number {
19392 if(!isWasmInitialized) {
19393 throw new Error("initializeWasm() must be awaited first!");
19395 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
19396 return nativeResponseValue;
19398 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
19400 export function UnsignedChannelUpdate_free(this_obj: number): void {
19401 if(!isWasmInitialized) {
19402 throw new Error("initializeWasm() must be awaited first!");
19404 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
19405 // debug statements here
19407 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
19409 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
19410 if(!isWasmInitialized) {
19411 throw new Error("initializeWasm() must be awaited first!");
19413 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
19414 return nativeResponseValue;
19416 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19418 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
19419 if(!isWasmInitialized) {
19420 throw new Error("initializeWasm() must be awaited first!");
19422 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
19423 // debug statements here
19425 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19427 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
19428 if(!isWasmInitialized) {
19429 throw new Error("initializeWasm() must be awaited first!");
19431 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
19432 return nativeResponseValue;
19434 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
19436 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
19437 if(!isWasmInitialized) {
19438 throw new Error("initializeWasm() must be awaited first!");
19440 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
19441 // debug statements here
19443 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19445 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
19446 if(!isWasmInitialized) {
19447 throw new Error("initializeWasm() must be awaited first!");
19449 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
19450 return nativeResponseValue;
19452 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
19454 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
19455 if(!isWasmInitialized) {
19456 throw new Error("initializeWasm() must be awaited first!");
19458 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
19459 // debug statements here
19461 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19463 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
19464 if(!isWasmInitialized) {
19465 throw new Error("initializeWasm() must be awaited first!");
19467 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
19468 return nativeResponseValue;
19470 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
19472 export function UnsignedChannelUpdate_set_flags(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_flags(this_ptr, val);
19477 // debug statements here
19479 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19481 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
19482 if(!isWasmInitialized) {
19483 throw new Error("initializeWasm() must be awaited first!");
19485 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
19486 return nativeResponseValue;
19488 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
19490 export function UnsignedChannelUpdate_set_cltv_expiry_delta(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_cltv_expiry_delta(this_ptr, val);
19495 // debug statements here
19497 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19499 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
19500 if(!isWasmInitialized) {
19501 throw new Error("initializeWasm() must be awaited first!");
19503 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
19504 return nativeResponseValue;
19506 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
19508 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
19509 if(!isWasmInitialized) {
19510 throw new Error("initializeWasm() must be awaited first!");
19512 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
19513 // debug statements here
19515 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19517 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
19518 if(!isWasmInitialized) {
19519 throw new Error("initializeWasm() must be awaited first!");
19521 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
19522 return nativeResponseValue;
19524 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
19526 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
19527 if(!isWasmInitialized) {
19528 throw new Error("initializeWasm() must be awaited first!");
19530 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
19531 // debug statements here
19533 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
19535 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
19536 if(!isWasmInitialized) {
19537 throw new Error("initializeWasm() must be awaited first!");
19539 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
19540 return nativeResponseValue;
19542 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
19544 export function UnsignedChannelUpdate_set_fee_proportional_millionths(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_proportional_millionths(this_ptr, val);
19549 // debug statements here
19551 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
19553 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
19554 if(!isWasmInitialized) {
19555 throw new Error("initializeWasm() must be awaited first!");
19557 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
19558 return nativeResponseValue;
19560 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
19562 export function UnsignedChannelUpdate_clone(orig: number): number {
19563 if(!isWasmInitialized) {
19564 throw new Error("initializeWasm() must be awaited first!");
19566 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
19567 return nativeResponseValue;
19569 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
19571 export function ChannelUpdate_free(this_obj: number): void {
19572 if(!isWasmInitialized) {
19573 throw new Error("initializeWasm() must be awaited first!");
19575 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
19576 // debug statements here
19578 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
19580 export function ChannelUpdate_get_signature(this_ptr: number): number {
19581 if(!isWasmInitialized) {
19582 throw new Error("initializeWasm() must be awaited first!");
19584 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
19585 return nativeResponseValue;
19587 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
19589 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
19590 if(!isWasmInitialized) {
19591 throw new Error("initializeWasm() must be awaited first!");
19593 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
19594 // debug statements here
19596 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
19598 export function ChannelUpdate_get_contents(this_ptr: number): number {
19599 if(!isWasmInitialized) {
19600 throw new Error("initializeWasm() must be awaited first!");
19602 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
19603 return nativeResponseValue;
19605 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
19607 export function ChannelUpdate_set_contents(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_contents(this_ptr, val);
19612 // debug statements here
19614 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
19616 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
19617 if(!isWasmInitialized) {
19618 throw new Error("initializeWasm() must be awaited first!");
19620 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
19621 return nativeResponseValue;
19623 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
19625 export function ChannelUpdate_clone_ptr(arg: number): number {
19626 if(!isWasmInitialized) {
19627 throw new Error("initializeWasm() must be awaited first!");
19629 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
19630 return nativeResponseValue;
19632 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
19634 export function ChannelUpdate_clone(orig: number): number {
19635 if(!isWasmInitialized) {
19636 throw new Error("initializeWasm() must be awaited first!");
19638 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
19639 return nativeResponseValue;
19641 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
19643 export function QueryChannelRange_free(this_obj: number): void {
19644 if(!isWasmInitialized) {
19645 throw new Error("initializeWasm() must be awaited first!");
19647 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
19648 // debug statements here
19650 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
19652 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
19653 if(!isWasmInitialized) {
19654 throw new Error("initializeWasm() must be awaited first!");
19656 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
19657 return nativeResponseValue;
19659 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19661 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
19662 if(!isWasmInitialized) {
19663 throw new Error("initializeWasm() must be awaited first!");
19665 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
19666 // debug statements here
19668 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
19670 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
19671 if(!isWasmInitialized) {
19672 throw new Error("initializeWasm() must be awaited first!");
19674 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
19675 return nativeResponseValue;
19677 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19679 export function QueryChannelRange_set_first_blocknum(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_first_blocknum(this_ptr, val);
19684 // debug statements here
19686 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
19688 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
19689 if(!isWasmInitialized) {
19690 throw new Error("initializeWasm() must be awaited first!");
19692 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
19693 return nativeResponseValue;
19695 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19697 export function QueryChannelRange_set_number_of_blocks(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_number_of_blocks(this_ptr, val);
19702 // debug statements here
19704 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
19706 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
19707 if(!isWasmInitialized) {
19708 throw new Error("initializeWasm() must be awaited first!");
19710 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
19711 return nativeResponseValue;
19713 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
19715 export function QueryChannelRange_clone_ptr(arg: number): number {
19716 if(!isWasmInitialized) {
19717 throw new Error("initializeWasm() must be awaited first!");
19719 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
19720 return nativeResponseValue;
19722 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
19724 export function QueryChannelRange_clone(orig: number): number {
19725 if(!isWasmInitialized) {
19726 throw new Error("initializeWasm() must be awaited first!");
19728 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
19729 return nativeResponseValue;
19731 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
19733 export function ReplyChannelRange_free(this_obj: number): void {
19734 if(!isWasmInitialized) {
19735 throw new Error("initializeWasm() must be awaited first!");
19737 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
19738 // debug statements here
19740 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
19742 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
19743 if(!isWasmInitialized) {
19744 throw new Error("initializeWasm() must be awaited first!");
19746 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
19747 return nativeResponseValue;
19749 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19751 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
19752 if(!isWasmInitialized) {
19753 throw new Error("initializeWasm() must be awaited first!");
19755 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
19756 // debug statements here
19758 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
19760 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
19761 if(!isWasmInitialized) {
19762 throw new Error("initializeWasm() must be awaited first!");
19764 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
19765 return nativeResponseValue;
19767 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19769 export function ReplyChannelRange_set_first_blocknum(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_first_blocknum(this_ptr, val);
19774 // debug statements here
19776 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
19778 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
19779 if(!isWasmInitialized) {
19780 throw new Error("initializeWasm() must be awaited first!");
19782 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
19783 return nativeResponseValue;
19785 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
19787 export function ReplyChannelRange_set_number_of_blocks(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_number_of_blocks(this_ptr, val);
19792 // debug statements here
19794 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
19796 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
19797 if(!isWasmInitialized) {
19798 throw new Error("initializeWasm() must be awaited first!");
19800 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
19801 return nativeResponseValue;
19803 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
19805 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
19806 if(!isWasmInitialized) {
19807 throw new Error("initializeWasm() must be awaited first!");
19809 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
19810 // debug statements here
19812 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
19814 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
19815 if(!isWasmInitialized) {
19816 throw new Error("initializeWasm() must be awaited first!");
19818 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
19819 // debug statements here
19821 // 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);
19823 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 {
19824 if(!isWasmInitialized) {
19825 throw new Error("initializeWasm() must be awaited first!");
19827 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
19828 return nativeResponseValue;
19830 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
19832 export function ReplyChannelRange_clone_ptr(arg: number): number {
19833 if(!isWasmInitialized) {
19834 throw new Error("initializeWasm() must be awaited first!");
19836 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
19837 return nativeResponseValue;
19839 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
19841 export function ReplyChannelRange_clone(orig: number): number {
19842 if(!isWasmInitialized) {
19843 throw new Error("initializeWasm() must be awaited first!");
19845 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
19846 return nativeResponseValue;
19848 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
19850 export function QueryShortChannelIds_free(this_obj: number): void {
19851 if(!isWasmInitialized) {
19852 throw new Error("initializeWasm() must be awaited first!");
19854 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
19855 // debug statements here
19857 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
19859 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
19860 if(!isWasmInitialized) {
19861 throw new Error("initializeWasm() must be awaited first!");
19863 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
19864 return nativeResponseValue;
19866 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19868 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
19869 if(!isWasmInitialized) {
19870 throw new Error("initializeWasm() must be awaited first!");
19872 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
19873 // debug statements here
19875 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
19877 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
19878 if(!isWasmInitialized) {
19879 throw new Error("initializeWasm() must be awaited first!");
19881 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
19882 // debug statements here
19884 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
19886 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
19887 if(!isWasmInitialized) {
19888 throw new Error("initializeWasm() must be awaited first!");
19890 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
19891 return nativeResponseValue;
19893 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
19895 export function QueryShortChannelIds_clone_ptr(arg: number): number {
19896 if(!isWasmInitialized) {
19897 throw new Error("initializeWasm() must be awaited first!");
19899 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
19900 return nativeResponseValue;
19902 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
19904 export function QueryShortChannelIds_clone(orig: number): number {
19905 if(!isWasmInitialized) {
19906 throw new Error("initializeWasm() must be awaited first!");
19908 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
19909 return nativeResponseValue;
19911 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
19913 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
19914 if(!isWasmInitialized) {
19915 throw new Error("initializeWasm() must be awaited first!");
19917 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
19918 // debug statements here
19920 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
19922 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
19923 if(!isWasmInitialized) {
19924 throw new Error("initializeWasm() must be awaited first!");
19926 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
19927 return nativeResponseValue;
19929 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19931 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
19932 if(!isWasmInitialized) {
19933 throw new Error("initializeWasm() must be awaited first!");
19935 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
19936 // debug statements here
19938 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
19940 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
19941 if(!isWasmInitialized) {
19942 throw new Error("initializeWasm() must be awaited first!");
19944 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
19945 return nativeResponseValue;
19947 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
19949 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
19950 if(!isWasmInitialized) {
19951 throw new Error("initializeWasm() must be awaited first!");
19953 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
19954 // debug statements here
19956 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
19958 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
19959 if(!isWasmInitialized) {
19960 throw new Error("initializeWasm() must be awaited first!");
19962 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
19963 return nativeResponseValue;
19965 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
19967 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
19968 if(!isWasmInitialized) {
19969 throw new Error("initializeWasm() must be awaited first!");
19971 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
19972 return nativeResponseValue;
19974 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
19976 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
19977 if(!isWasmInitialized) {
19978 throw new Error("initializeWasm() must be awaited first!");
19980 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
19981 return nativeResponseValue;
19983 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
19985 export function GossipTimestampFilter_free(this_obj: number): void {
19986 if(!isWasmInitialized) {
19987 throw new Error("initializeWasm() must be awaited first!");
19989 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
19990 // debug statements here
19992 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
19994 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
19995 if(!isWasmInitialized) {
19996 throw new Error("initializeWasm() must be awaited first!");
19998 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
19999 return nativeResponseValue;
20001 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20003 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
20004 if(!isWasmInitialized) {
20005 throw new Error("initializeWasm() must be awaited first!");
20007 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
20008 // debug statements here
20010 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
20012 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
20013 if(!isWasmInitialized) {
20014 throw new Error("initializeWasm() must be awaited first!");
20016 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
20017 return nativeResponseValue;
20019 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
20021 export function GossipTimestampFilter_set_first_timestamp(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_first_timestamp(this_ptr, val);
20026 // debug statements here
20028 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
20030 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
20031 if(!isWasmInitialized) {
20032 throw new Error("initializeWasm() must be awaited first!");
20034 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
20035 return nativeResponseValue;
20037 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
20039 export function GossipTimestampFilter_set_timestamp_range(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_timestamp_range(this_ptr, val);
20044 // debug statements here
20046 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
20048 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
20049 if(!isWasmInitialized) {
20050 throw new Error("initializeWasm() must be awaited first!");
20052 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
20053 return nativeResponseValue;
20055 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
20057 export function GossipTimestampFilter_clone_ptr(arg: number): number {
20058 if(!isWasmInitialized) {
20059 throw new Error("initializeWasm() must be awaited first!");
20061 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
20062 return nativeResponseValue;
20064 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
20066 export function GossipTimestampFilter_clone(orig: number): number {
20067 if(!isWasmInitialized) {
20068 throw new Error("initializeWasm() must be awaited first!");
20070 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
20071 return nativeResponseValue;
20073 // void ErrorAction_free(struct LDKErrorAction this_ptr);
20075 export function ErrorAction_free(this_ptr: number): void {
20076 if(!isWasmInitialized) {
20077 throw new Error("initializeWasm() must be awaited first!");
20079 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
20080 // debug statements here
20082 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
20084 export function ErrorAction_clone_ptr(arg: number): number {
20085 if(!isWasmInitialized) {
20086 throw new Error("initializeWasm() must be awaited first!");
20088 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
20089 return nativeResponseValue;
20091 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
20093 export function ErrorAction_clone(orig: number): number {
20094 if(!isWasmInitialized) {
20095 throw new Error("initializeWasm() must be awaited first!");
20097 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
20098 return nativeResponseValue;
20100 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
20102 export function ErrorAction_disconnect_peer(msg: number): number {
20103 if(!isWasmInitialized) {
20104 throw new Error("initializeWasm() must be awaited first!");
20106 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
20107 return nativeResponseValue;
20109 // struct LDKErrorAction ErrorAction_ignore_error(void);
20111 export function ErrorAction_ignore_error(): number {
20112 if(!isWasmInitialized) {
20113 throw new Error("initializeWasm() must be awaited first!");
20115 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
20116 return nativeResponseValue;
20118 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
20120 export function ErrorAction_ignore_and_log(a: Level): number {
20121 if(!isWasmInitialized) {
20122 throw new Error("initializeWasm() must be awaited first!");
20124 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
20125 return nativeResponseValue;
20127 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
20129 export function ErrorAction_ignore_duplicate_gossip(): number {
20130 if(!isWasmInitialized) {
20131 throw new Error("initializeWasm() must be awaited first!");
20133 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
20134 return nativeResponseValue;
20136 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
20138 export function ErrorAction_send_error_message(msg: number): number {
20139 if(!isWasmInitialized) {
20140 throw new Error("initializeWasm() must be awaited first!");
20142 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
20143 return nativeResponseValue;
20145 // void LightningError_free(struct LDKLightningError this_obj);
20147 export function LightningError_free(this_obj: number): void {
20148 if(!isWasmInitialized) {
20149 throw new Error("initializeWasm() must be awaited first!");
20151 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
20152 // debug statements here
20154 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
20156 export function LightningError_get_err(this_ptr: number): number {
20157 if(!isWasmInitialized) {
20158 throw new Error("initializeWasm() must be awaited first!");
20160 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
20161 return nativeResponseValue;
20163 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
20165 export function LightningError_set_err(this_ptr: number, val: number): void {
20166 if(!isWasmInitialized) {
20167 throw new Error("initializeWasm() must be awaited first!");
20169 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
20170 // debug statements here
20172 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
20174 export function LightningError_get_action(this_ptr: number): number {
20175 if(!isWasmInitialized) {
20176 throw new Error("initializeWasm() must be awaited first!");
20178 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
20179 return nativeResponseValue;
20181 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
20183 export function LightningError_set_action(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_action(this_ptr, val);
20188 // debug statements here
20190 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
20192 export function LightningError_new(err_arg: number, action_arg: number): number {
20193 if(!isWasmInitialized) {
20194 throw new Error("initializeWasm() must be awaited first!");
20196 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
20197 return nativeResponseValue;
20199 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
20201 export function LightningError_clone_ptr(arg: number): number {
20202 if(!isWasmInitialized) {
20203 throw new Error("initializeWasm() must be awaited first!");
20205 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
20206 return nativeResponseValue;
20208 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
20210 export function LightningError_clone(orig: number): number {
20211 if(!isWasmInitialized) {
20212 throw new Error("initializeWasm() must be awaited first!");
20214 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
20215 return nativeResponseValue;
20217 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
20219 export function CommitmentUpdate_free(this_obj: number): void {
20220 if(!isWasmInitialized) {
20221 throw new Error("initializeWasm() must be awaited first!");
20223 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
20224 // debug statements here
20226 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20228 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
20229 if(!isWasmInitialized) {
20230 throw new Error("initializeWasm() must be awaited first!");
20232 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
20233 return nativeResponseValue;
20235 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
20237 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
20238 if(!isWasmInitialized) {
20239 throw new Error("initializeWasm() must be awaited first!");
20241 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
20242 // debug statements here
20244 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20246 export function CommitmentUpdate_get_update_fulfill_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_fulfill_htlcs(this_ptr);
20251 return nativeResponseValue;
20253 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
20255 export function CommitmentUpdate_set_update_fulfill_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_fulfill_htlcs(this_ptr, val);
20260 // debug statements here
20262 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20264 export function CommitmentUpdate_get_update_fail_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_fail_htlcs(this_ptr);
20269 return nativeResponseValue;
20271 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
20273 export function CommitmentUpdate_set_update_fail_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_fail_htlcs(this_ptr, val);
20278 // debug statements here
20280 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20282 export function CommitmentUpdate_get_update_fail_malformed_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_malformed_htlcs(this_ptr);
20287 return nativeResponseValue;
20289 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
20291 export function CommitmentUpdate_set_update_fail_malformed_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_malformed_htlcs(this_ptr, val);
20296 // debug statements here
20298 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20300 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
20301 if(!isWasmInitialized) {
20302 throw new Error("initializeWasm() must be awaited first!");
20304 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
20305 return nativeResponseValue;
20307 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
20309 export function CommitmentUpdate_set_update_fee(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_fee(this_ptr, val);
20314 // debug statements here
20316 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
20318 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
20319 if(!isWasmInitialized) {
20320 throw new Error("initializeWasm() must be awaited first!");
20322 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
20323 return nativeResponseValue;
20325 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
20327 export function CommitmentUpdate_set_commitment_signed(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_commitment_signed(this_ptr, val);
20332 // debug statements here
20334 // 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);
20336 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 {
20337 if(!isWasmInitialized) {
20338 throw new Error("initializeWasm() must be awaited first!");
20340 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);
20341 return nativeResponseValue;
20343 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
20345 export function CommitmentUpdate_clone_ptr(arg: number): number {
20346 if(!isWasmInitialized) {
20347 throw new Error("initializeWasm() must be awaited first!");
20349 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
20350 return nativeResponseValue;
20352 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
20354 export function CommitmentUpdate_clone(orig: number): number {
20355 if(!isWasmInitialized) {
20356 throw new Error("initializeWasm() must be awaited first!");
20358 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
20359 return nativeResponseValue;
20361 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
20363 export function ChannelMessageHandler_free(this_ptr: number): void {
20364 if(!isWasmInitialized) {
20365 throw new Error("initializeWasm() must be awaited first!");
20367 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
20368 // debug statements here
20370 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
20372 export function RoutingMessageHandler_free(this_ptr: number): void {
20373 if(!isWasmInitialized) {
20374 throw new Error("initializeWasm() must be awaited first!");
20376 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
20377 // debug statements here
20379 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
20381 export function AcceptChannel_write(obj: number): number {
20382 if(!isWasmInitialized) {
20383 throw new Error("initializeWasm() must be awaited first!");
20385 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
20386 return nativeResponseValue;
20388 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
20390 export function AcceptChannel_read(ser: number): number {
20391 if(!isWasmInitialized) {
20392 throw new Error("initializeWasm() must be awaited first!");
20394 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
20395 return nativeResponseValue;
20397 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
20399 export function AnnouncementSignatures_write(obj: number): number {
20400 if(!isWasmInitialized) {
20401 throw new Error("initializeWasm() must be awaited first!");
20403 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
20404 return nativeResponseValue;
20406 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
20408 export function AnnouncementSignatures_read(ser: number): number {
20409 if(!isWasmInitialized) {
20410 throw new Error("initializeWasm() must be awaited first!");
20412 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
20413 return nativeResponseValue;
20415 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
20417 export function ChannelReestablish_write(obj: number): number {
20418 if(!isWasmInitialized) {
20419 throw new Error("initializeWasm() must be awaited first!");
20421 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
20422 return nativeResponseValue;
20424 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
20426 export function ChannelReestablish_read(ser: number): number {
20427 if(!isWasmInitialized) {
20428 throw new Error("initializeWasm() must be awaited first!");
20430 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
20431 return nativeResponseValue;
20433 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
20435 export function ClosingSigned_write(obj: number): number {
20436 if(!isWasmInitialized) {
20437 throw new Error("initializeWasm() must be awaited first!");
20439 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
20440 return nativeResponseValue;
20442 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
20444 export function ClosingSigned_read(ser: number): number {
20445 if(!isWasmInitialized) {
20446 throw new Error("initializeWasm() must be awaited first!");
20448 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
20449 return nativeResponseValue;
20451 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
20453 export function ClosingSignedFeeRange_write(obj: number): number {
20454 if(!isWasmInitialized) {
20455 throw new Error("initializeWasm() must be awaited first!");
20457 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
20458 return nativeResponseValue;
20460 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
20462 export function ClosingSignedFeeRange_read(ser: number): number {
20463 if(!isWasmInitialized) {
20464 throw new Error("initializeWasm() must be awaited first!");
20466 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
20467 return nativeResponseValue;
20469 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
20471 export function CommitmentSigned_write(obj: number): number {
20472 if(!isWasmInitialized) {
20473 throw new Error("initializeWasm() must be awaited first!");
20475 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
20476 return nativeResponseValue;
20478 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
20480 export function CommitmentSigned_read(ser: number): number {
20481 if(!isWasmInitialized) {
20482 throw new Error("initializeWasm() must be awaited first!");
20484 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
20485 return nativeResponseValue;
20487 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
20489 export function FundingCreated_write(obj: number): number {
20490 if(!isWasmInitialized) {
20491 throw new Error("initializeWasm() must be awaited first!");
20493 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
20494 return nativeResponseValue;
20496 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
20498 export function FundingCreated_read(ser: number): number {
20499 if(!isWasmInitialized) {
20500 throw new Error("initializeWasm() must be awaited first!");
20502 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
20503 return nativeResponseValue;
20505 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
20507 export function FundingSigned_write(obj: number): number {
20508 if(!isWasmInitialized) {
20509 throw new Error("initializeWasm() must be awaited first!");
20511 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
20512 return nativeResponseValue;
20514 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
20516 export function FundingSigned_read(ser: number): number {
20517 if(!isWasmInitialized) {
20518 throw new Error("initializeWasm() must be awaited first!");
20520 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
20521 return nativeResponseValue;
20523 // struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
20525 export function FundingLocked_write(obj: number): number {
20526 if(!isWasmInitialized) {
20527 throw new Error("initializeWasm() must be awaited first!");
20529 const nativeResponseValue = wasm.TS_FundingLocked_write(obj);
20530 return nativeResponseValue;
20532 // struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
20534 export function FundingLocked_read(ser: number): number {
20535 if(!isWasmInitialized) {
20536 throw new Error("initializeWasm() must be awaited first!");
20538 const nativeResponseValue = wasm.TS_FundingLocked_read(ser);
20539 return nativeResponseValue;
20541 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
20543 export function Init_write(obj: number): number {
20544 if(!isWasmInitialized) {
20545 throw new Error("initializeWasm() must be awaited first!");
20547 const nativeResponseValue = wasm.TS_Init_write(obj);
20548 return nativeResponseValue;
20550 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
20552 export function Init_read(ser: number): number {
20553 if(!isWasmInitialized) {
20554 throw new Error("initializeWasm() must be awaited first!");
20556 const nativeResponseValue = wasm.TS_Init_read(ser);
20557 return nativeResponseValue;
20559 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
20561 export function OpenChannel_write(obj: number): number {
20562 if(!isWasmInitialized) {
20563 throw new Error("initializeWasm() must be awaited first!");
20565 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
20566 return nativeResponseValue;
20568 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
20570 export function OpenChannel_read(ser: number): number {
20571 if(!isWasmInitialized) {
20572 throw new Error("initializeWasm() must be awaited first!");
20574 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
20575 return nativeResponseValue;
20577 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
20579 export function RevokeAndACK_write(obj: number): number {
20580 if(!isWasmInitialized) {
20581 throw new Error("initializeWasm() must be awaited first!");
20583 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
20584 return nativeResponseValue;
20586 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
20588 export function RevokeAndACK_read(ser: number): number {
20589 if(!isWasmInitialized) {
20590 throw new Error("initializeWasm() must be awaited first!");
20592 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
20593 return nativeResponseValue;
20595 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
20597 export function Shutdown_write(obj: number): number {
20598 if(!isWasmInitialized) {
20599 throw new Error("initializeWasm() must be awaited first!");
20601 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
20602 return nativeResponseValue;
20604 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
20606 export function Shutdown_read(ser: number): number {
20607 if(!isWasmInitialized) {
20608 throw new Error("initializeWasm() must be awaited first!");
20610 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
20611 return nativeResponseValue;
20613 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
20615 export function UpdateFailHTLC_write(obj: number): number {
20616 if(!isWasmInitialized) {
20617 throw new Error("initializeWasm() must be awaited first!");
20619 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
20620 return nativeResponseValue;
20622 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
20624 export function UpdateFailHTLC_read(ser: number): number {
20625 if(!isWasmInitialized) {
20626 throw new Error("initializeWasm() must be awaited first!");
20628 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
20629 return nativeResponseValue;
20631 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
20633 export function UpdateFailMalformedHTLC_write(obj: number): number {
20634 if(!isWasmInitialized) {
20635 throw new Error("initializeWasm() must be awaited first!");
20637 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
20638 return nativeResponseValue;
20640 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
20642 export function UpdateFailMalformedHTLC_read(ser: number): number {
20643 if(!isWasmInitialized) {
20644 throw new Error("initializeWasm() must be awaited first!");
20646 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
20647 return nativeResponseValue;
20649 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
20651 export function UpdateFee_write(obj: number): number {
20652 if(!isWasmInitialized) {
20653 throw new Error("initializeWasm() must be awaited first!");
20655 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
20656 return nativeResponseValue;
20658 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
20660 export function UpdateFee_read(ser: number): number {
20661 if(!isWasmInitialized) {
20662 throw new Error("initializeWasm() must be awaited first!");
20664 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
20665 return nativeResponseValue;
20667 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
20669 export function UpdateFulfillHTLC_write(obj: number): number {
20670 if(!isWasmInitialized) {
20671 throw new Error("initializeWasm() must be awaited first!");
20673 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
20674 return nativeResponseValue;
20676 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
20678 export function UpdateFulfillHTLC_read(ser: number): number {
20679 if(!isWasmInitialized) {
20680 throw new Error("initializeWasm() must be awaited first!");
20682 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
20683 return nativeResponseValue;
20685 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
20687 export function UpdateAddHTLC_write(obj: number): number {
20688 if(!isWasmInitialized) {
20689 throw new Error("initializeWasm() must be awaited first!");
20691 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
20692 return nativeResponseValue;
20694 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
20696 export function UpdateAddHTLC_read(ser: number): number {
20697 if(!isWasmInitialized) {
20698 throw new Error("initializeWasm() must be awaited first!");
20700 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
20701 return nativeResponseValue;
20703 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
20705 export function Ping_write(obj: number): number {
20706 if(!isWasmInitialized) {
20707 throw new Error("initializeWasm() must be awaited first!");
20709 const nativeResponseValue = wasm.TS_Ping_write(obj);
20710 return nativeResponseValue;
20712 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
20714 export function Ping_read(ser: number): number {
20715 if(!isWasmInitialized) {
20716 throw new Error("initializeWasm() must be awaited first!");
20718 const nativeResponseValue = wasm.TS_Ping_read(ser);
20719 return nativeResponseValue;
20721 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
20723 export function Pong_write(obj: number): number {
20724 if(!isWasmInitialized) {
20725 throw new Error("initializeWasm() must be awaited first!");
20727 const nativeResponseValue = wasm.TS_Pong_write(obj);
20728 return nativeResponseValue;
20730 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
20732 export function Pong_read(ser: number): number {
20733 if(!isWasmInitialized) {
20734 throw new Error("initializeWasm() must be awaited first!");
20736 const nativeResponseValue = wasm.TS_Pong_read(ser);
20737 return nativeResponseValue;
20739 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
20741 export function UnsignedChannelAnnouncement_write(obj: number): number {
20742 if(!isWasmInitialized) {
20743 throw new Error("initializeWasm() must be awaited first!");
20745 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
20746 return nativeResponseValue;
20748 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
20750 export function UnsignedChannelAnnouncement_read(ser: number): number {
20751 if(!isWasmInitialized) {
20752 throw new Error("initializeWasm() must be awaited first!");
20754 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
20755 return nativeResponseValue;
20757 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
20759 export function ChannelAnnouncement_write(obj: number): number {
20760 if(!isWasmInitialized) {
20761 throw new Error("initializeWasm() must be awaited first!");
20763 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
20764 return nativeResponseValue;
20766 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
20768 export function ChannelAnnouncement_read(ser: number): number {
20769 if(!isWasmInitialized) {
20770 throw new Error("initializeWasm() must be awaited first!");
20772 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
20773 return nativeResponseValue;
20775 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
20777 export function UnsignedChannelUpdate_write(obj: number): number {
20778 if(!isWasmInitialized) {
20779 throw new Error("initializeWasm() must be awaited first!");
20781 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
20782 return nativeResponseValue;
20784 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
20786 export function UnsignedChannelUpdate_read(ser: number): number {
20787 if(!isWasmInitialized) {
20788 throw new Error("initializeWasm() must be awaited first!");
20790 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
20791 return nativeResponseValue;
20793 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
20795 export function ChannelUpdate_write(obj: number): number {
20796 if(!isWasmInitialized) {
20797 throw new Error("initializeWasm() must be awaited first!");
20799 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
20800 return nativeResponseValue;
20802 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
20804 export function ChannelUpdate_read(ser: number): number {
20805 if(!isWasmInitialized) {
20806 throw new Error("initializeWasm() must be awaited first!");
20808 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
20809 return nativeResponseValue;
20811 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
20813 export function ErrorMessage_write(obj: number): number {
20814 if(!isWasmInitialized) {
20815 throw new Error("initializeWasm() must be awaited first!");
20817 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
20818 return nativeResponseValue;
20820 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
20822 export function ErrorMessage_read(ser: number): number {
20823 if(!isWasmInitialized) {
20824 throw new Error("initializeWasm() must be awaited first!");
20826 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
20827 return nativeResponseValue;
20829 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
20831 export function UnsignedNodeAnnouncement_write(obj: number): number {
20832 if(!isWasmInitialized) {
20833 throw new Error("initializeWasm() must be awaited first!");
20835 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
20836 return nativeResponseValue;
20838 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
20840 export function UnsignedNodeAnnouncement_read(ser: number): number {
20841 if(!isWasmInitialized) {
20842 throw new Error("initializeWasm() must be awaited first!");
20844 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
20845 return nativeResponseValue;
20847 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
20849 export function NodeAnnouncement_write(obj: number): number {
20850 if(!isWasmInitialized) {
20851 throw new Error("initializeWasm() must be awaited first!");
20853 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
20854 return nativeResponseValue;
20856 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
20858 export function NodeAnnouncement_read(ser: number): number {
20859 if(!isWasmInitialized) {
20860 throw new Error("initializeWasm() must be awaited first!");
20862 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
20863 return nativeResponseValue;
20865 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
20867 export function QueryShortChannelIds_read(ser: number): number {
20868 if(!isWasmInitialized) {
20869 throw new Error("initializeWasm() must be awaited first!");
20871 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
20872 return nativeResponseValue;
20874 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
20876 export function QueryShortChannelIds_write(obj: number): number {
20877 if(!isWasmInitialized) {
20878 throw new Error("initializeWasm() must be awaited first!");
20880 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
20881 return nativeResponseValue;
20883 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
20885 export function ReplyShortChannelIdsEnd_write(obj: number): number {
20886 if(!isWasmInitialized) {
20887 throw new Error("initializeWasm() must be awaited first!");
20889 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
20890 return nativeResponseValue;
20892 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
20894 export function ReplyShortChannelIdsEnd_read(ser: number): number {
20895 if(!isWasmInitialized) {
20896 throw new Error("initializeWasm() must be awaited first!");
20898 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
20899 return nativeResponseValue;
20901 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
20903 export function QueryChannelRange_end_blocknum(this_arg: number): number {
20904 if(!isWasmInitialized) {
20905 throw new Error("initializeWasm() must be awaited first!");
20907 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
20908 return nativeResponseValue;
20910 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
20912 export function QueryChannelRange_write(obj: number): number {
20913 if(!isWasmInitialized) {
20914 throw new Error("initializeWasm() must be awaited first!");
20916 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
20917 return nativeResponseValue;
20919 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
20921 export function QueryChannelRange_read(ser: number): number {
20922 if(!isWasmInitialized) {
20923 throw new Error("initializeWasm() must be awaited first!");
20925 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
20926 return nativeResponseValue;
20928 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
20930 export function ReplyChannelRange_read(ser: number): number {
20931 if(!isWasmInitialized) {
20932 throw new Error("initializeWasm() must be awaited first!");
20934 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
20935 return nativeResponseValue;
20937 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
20939 export function ReplyChannelRange_write(obj: number): number {
20940 if(!isWasmInitialized) {
20941 throw new Error("initializeWasm() must be awaited first!");
20943 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
20944 return nativeResponseValue;
20946 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
20948 export function GossipTimestampFilter_write(obj: number): number {
20949 if(!isWasmInitialized) {
20950 throw new Error("initializeWasm() must be awaited first!");
20952 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
20953 return nativeResponseValue;
20955 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
20957 export function GossipTimestampFilter_read(ser: number): number {
20958 if(!isWasmInitialized) {
20959 throw new Error("initializeWasm() must be awaited first!");
20961 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
20962 return nativeResponseValue;
20964 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
20966 export function CustomMessageHandler_free(this_ptr: number): void {
20967 if(!isWasmInitialized) {
20968 throw new Error("initializeWasm() must be awaited first!");
20970 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
20971 // debug statements here
20973 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
20975 export function IgnoringMessageHandler_free(this_obj: number): void {
20976 if(!isWasmInitialized) {
20977 throw new Error("initializeWasm() must be awaited first!");
20979 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
20980 // debug statements here
20982 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
20984 export function IgnoringMessageHandler_new(): number {
20985 if(!isWasmInitialized) {
20986 throw new Error("initializeWasm() must be awaited first!");
20988 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
20989 return nativeResponseValue;
20991 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
20993 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
20994 if(!isWasmInitialized) {
20995 throw new Error("initializeWasm() must be awaited first!");
20997 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
20998 return nativeResponseValue;
21000 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21002 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
21003 if(!isWasmInitialized) {
21004 throw new Error("initializeWasm() must be awaited first!");
21006 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
21007 return nativeResponseValue;
21009 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21011 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
21012 if(!isWasmInitialized) {
21013 throw new Error("initializeWasm() must be awaited first!");
21015 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
21016 return nativeResponseValue;
21018 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
21020 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
21021 if(!isWasmInitialized) {
21022 throw new Error("initializeWasm() must be awaited first!");
21024 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
21025 return nativeResponseValue;
21027 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
21029 export function ErroringMessageHandler_free(this_obj: number): void {
21030 if(!isWasmInitialized) {
21031 throw new Error("initializeWasm() must be awaited first!");
21033 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
21034 // debug statements here
21036 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
21038 export function ErroringMessageHandler_new(): number {
21039 if(!isWasmInitialized) {
21040 throw new Error("initializeWasm() must be awaited first!");
21042 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
21043 return nativeResponseValue;
21045 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
21047 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
21048 if(!isWasmInitialized) {
21049 throw new Error("initializeWasm() must be awaited first!");
21051 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
21052 return nativeResponseValue;
21054 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
21056 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
21057 if(!isWasmInitialized) {
21058 throw new Error("initializeWasm() must be awaited first!");
21060 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
21061 return nativeResponseValue;
21063 // void MessageHandler_free(struct LDKMessageHandler this_obj);
21065 export function MessageHandler_free(this_obj: number): void {
21066 if(!isWasmInitialized) {
21067 throw new Error("initializeWasm() must be awaited first!");
21069 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
21070 // debug statements here
21072 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
21074 export function MessageHandler_get_chan_handler(this_ptr: number): number {
21075 if(!isWasmInitialized) {
21076 throw new Error("initializeWasm() must be awaited first!");
21078 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
21079 return nativeResponseValue;
21081 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
21083 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
21084 if(!isWasmInitialized) {
21085 throw new Error("initializeWasm() must be awaited first!");
21087 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
21088 // debug statements here
21090 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
21092 export function MessageHandler_get_route_handler(this_ptr: number): number {
21093 if(!isWasmInitialized) {
21094 throw new Error("initializeWasm() must be awaited first!");
21096 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
21097 return nativeResponseValue;
21099 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
21101 export function MessageHandler_set_route_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_route_handler(this_ptr, val);
21106 // debug statements here
21108 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
21110 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
21111 if(!isWasmInitialized) {
21112 throw new Error("initializeWasm() must be awaited first!");
21114 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
21115 return nativeResponseValue;
21117 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
21119 export function SocketDescriptor_clone_ptr(arg: number): number {
21120 if(!isWasmInitialized) {
21121 throw new Error("initializeWasm() must be awaited first!");
21123 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
21124 return nativeResponseValue;
21126 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
21128 export function SocketDescriptor_clone(orig: number): number {
21129 if(!isWasmInitialized) {
21130 throw new Error("initializeWasm() must be awaited first!");
21132 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
21133 return nativeResponseValue;
21135 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
21137 export function SocketDescriptor_free(this_ptr: number): void {
21138 if(!isWasmInitialized) {
21139 throw new Error("initializeWasm() must be awaited first!");
21141 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
21142 // debug statements here
21144 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
21146 export function PeerHandleError_free(this_obj: number): void {
21147 if(!isWasmInitialized) {
21148 throw new Error("initializeWasm() must be awaited first!");
21150 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
21151 // debug statements here
21153 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
21155 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
21156 if(!isWasmInitialized) {
21157 throw new Error("initializeWasm() must be awaited first!");
21159 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
21160 return nativeResponseValue;
21162 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
21164 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
21165 if(!isWasmInitialized) {
21166 throw new Error("initializeWasm() must be awaited first!");
21168 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
21169 // debug statements here
21171 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
21173 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
21174 if(!isWasmInitialized) {
21175 throw new Error("initializeWasm() must be awaited first!");
21177 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
21178 return nativeResponseValue;
21180 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
21182 export function PeerHandleError_clone_ptr(arg: number): number {
21183 if(!isWasmInitialized) {
21184 throw new Error("initializeWasm() must be awaited first!");
21186 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
21187 return nativeResponseValue;
21189 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
21191 export function PeerHandleError_clone(orig: number): number {
21192 if(!isWasmInitialized) {
21193 throw new Error("initializeWasm() must be awaited first!");
21195 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
21196 return nativeResponseValue;
21198 // void PeerManager_free(struct LDKPeerManager this_obj);
21200 export function PeerManager_free(this_obj: number): void {
21201 if(!isWasmInitialized) {
21202 throw new Error("initializeWasm() must be awaited first!");
21204 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
21205 // debug statements here
21207 // 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);
21209 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
21210 if(!isWasmInitialized) {
21211 throw new Error("initializeWasm() must be awaited first!");
21213 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
21214 return nativeResponseValue;
21216 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
21218 export function PeerManager_get_peer_node_ids(this_arg: number): number {
21219 if(!isWasmInitialized) {
21220 throw new Error("initializeWasm() must be awaited first!");
21222 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
21223 return nativeResponseValue;
21225 // 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);
21227 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number): number {
21228 if(!isWasmInitialized) {
21229 throw new Error("initializeWasm() must be awaited first!");
21231 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor);
21232 return nativeResponseValue;
21234 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor);
21236 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number): number {
21237 if(!isWasmInitialized) {
21238 throw new Error("initializeWasm() must be awaited first!");
21240 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor);
21241 return nativeResponseValue;
21243 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
21245 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
21246 if(!isWasmInitialized) {
21247 throw new Error("initializeWasm() must be awaited first!");
21249 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
21250 return nativeResponseValue;
21252 // 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);
21254 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
21255 if(!isWasmInitialized) {
21256 throw new Error("initializeWasm() must be awaited first!");
21258 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
21259 return nativeResponseValue;
21261 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
21263 export function PeerManager_process_events(this_arg: number): void {
21264 if(!isWasmInitialized) {
21265 throw new Error("initializeWasm() must be awaited first!");
21267 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
21268 // debug statements here
21270 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
21272 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
21273 if(!isWasmInitialized) {
21274 throw new Error("initializeWasm() must be awaited first!");
21276 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
21277 // debug statements here
21279 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
21281 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
21282 if(!isWasmInitialized) {
21283 throw new Error("initializeWasm() must be awaited first!");
21285 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
21286 // debug statements here
21288 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
21290 export function PeerManager_disconnect_all_peers(this_arg: number): void {
21291 if(!isWasmInitialized) {
21292 throw new Error("initializeWasm() must be awaited first!");
21294 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
21295 // debug statements here
21297 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
21299 export function PeerManager_timer_tick_occurred(this_arg: number): void {
21300 if(!isWasmInitialized) {
21301 throw new Error("initializeWasm() must be awaited first!");
21303 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
21304 // debug statements here
21306 // uint64_t htlc_success_tx_weight(bool opt_anchors);
21308 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
21309 if(!isWasmInitialized) {
21310 throw new Error("initializeWasm() must be awaited first!");
21312 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
21313 return nativeResponseValue;
21315 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
21317 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
21318 if(!isWasmInitialized) {
21319 throw new Error("initializeWasm() must be awaited first!");
21321 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
21322 return nativeResponseValue;
21324 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
21326 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
21327 if(!isWasmInitialized) {
21328 throw new Error("initializeWasm() must be awaited first!");
21330 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
21331 return nativeResponseValue;
21333 // 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);
21335 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 {
21336 if(!isWasmInitialized) {
21337 throw new Error("initializeWasm() must be awaited first!");
21339 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
21340 return nativeResponseValue;
21342 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
21344 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
21345 if(!isWasmInitialized) {
21346 throw new Error("initializeWasm() must be awaited first!");
21348 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
21349 return nativeResponseValue;
21351 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
21353 export function derive_public_key(per_commitment_point: number, base_point: number): number {
21354 if(!isWasmInitialized) {
21355 throw new Error("initializeWasm() must be awaited first!");
21357 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
21358 return nativeResponseValue;
21360 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
21362 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
21363 if(!isWasmInitialized) {
21364 throw new Error("initializeWasm() must be awaited first!");
21366 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
21367 return nativeResponseValue;
21369 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
21371 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
21372 if(!isWasmInitialized) {
21373 throw new Error("initializeWasm() must be awaited first!");
21375 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
21376 return nativeResponseValue;
21378 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
21380 export function TxCreationKeys_free(this_obj: number): void {
21381 if(!isWasmInitialized) {
21382 throw new Error("initializeWasm() must be awaited first!");
21384 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
21385 // debug statements here
21387 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21389 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
21390 if(!isWasmInitialized) {
21391 throw new Error("initializeWasm() must be awaited first!");
21393 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
21394 return nativeResponseValue;
21396 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21398 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
21399 if(!isWasmInitialized) {
21400 throw new Error("initializeWasm() must be awaited first!");
21402 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
21403 // debug statements here
21405 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21407 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
21408 if(!isWasmInitialized) {
21409 throw new Error("initializeWasm() must be awaited first!");
21411 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
21412 return nativeResponseValue;
21414 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21416 export function TxCreationKeys_set_revocation_key(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_revocation_key(this_ptr, val);
21421 // debug statements here
21423 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21425 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
21426 if(!isWasmInitialized) {
21427 throw new Error("initializeWasm() must be awaited first!");
21429 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
21430 return nativeResponseValue;
21432 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21434 export function TxCreationKeys_set_broadcaster_htlc_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_broadcaster_htlc_key(this_ptr, val);
21439 // debug statements here
21441 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21443 export function TxCreationKeys_get_countersignatory_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_countersignatory_htlc_key(this_ptr);
21448 return nativeResponseValue;
21450 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21452 export function TxCreationKeys_set_countersignatory_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_countersignatory_htlc_key(this_ptr, val);
21457 // debug statements here
21459 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
21461 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
21462 if(!isWasmInitialized) {
21463 throw new Error("initializeWasm() must be awaited first!");
21465 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
21466 return nativeResponseValue;
21468 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21470 export function TxCreationKeys_set_broadcaster_delayed_payment_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_broadcaster_delayed_payment_key(this_ptr, val);
21475 // debug statements here
21477 // 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);
21479 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 {
21480 if(!isWasmInitialized) {
21481 throw new Error("initializeWasm() must be awaited first!");
21483 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);
21484 return nativeResponseValue;
21486 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
21488 export function TxCreationKeys_clone_ptr(arg: number): number {
21489 if(!isWasmInitialized) {
21490 throw new Error("initializeWasm() must be awaited first!");
21492 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
21493 return nativeResponseValue;
21495 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
21497 export function TxCreationKeys_clone(orig: number): number {
21498 if(!isWasmInitialized) {
21499 throw new Error("initializeWasm() must be awaited first!");
21501 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
21502 return nativeResponseValue;
21504 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
21506 export function TxCreationKeys_write(obj: number): number {
21507 if(!isWasmInitialized) {
21508 throw new Error("initializeWasm() must be awaited first!");
21510 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
21511 return nativeResponseValue;
21513 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
21515 export function TxCreationKeys_read(ser: number): number {
21516 if(!isWasmInitialized) {
21517 throw new Error("initializeWasm() must be awaited first!");
21519 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
21520 return nativeResponseValue;
21522 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
21524 export function ChannelPublicKeys_free(this_obj: number): void {
21525 if(!isWasmInitialized) {
21526 throw new Error("initializeWasm() must be awaited first!");
21528 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
21529 // debug statements here
21531 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21533 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
21534 if(!isWasmInitialized) {
21535 throw new Error("initializeWasm() must be awaited first!");
21537 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
21538 return nativeResponseValue;
21540 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21542 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
21543 if(!isWasmInitialized) {
21544 throw new Error("initializeWasm() must be awaited first!");
21546 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
21547 // debug statements here
21549 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21551 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
21552 if(!isWasmInitialized) {
21553 throw new Error("initializeWasm() must be awaited first!");
21555 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
21556 return nativeResponseValue;
21558 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21560 export function ChannelPublicKeys_set_revocation_basepoint(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_revocation_basepoint(this_ptr, val);
21565 // debug statements here
21567 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21569 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
21570 if(!isWasmInitialized) {
21571 throw new Error("initializeWasm() must be awaited first!");
21573 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
21574 return nativeResponseValue;
21576 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21578 export function ChannelPublicKeys_set_payment_point(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_payment_point(this_ptr, val);
21583 // debug statements here
21585 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21587 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
21588 if(!isWasmInitialized) {
21589 throw new Error("initializeWasm() must be awaited first!");
21591 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
21592 return nativeResponseValue;
21594 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21596 export function ChannelPublicKeys_set_delayed_payment_basepoint(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_delayed_payment_basepoint(this_ptr, val);
21601 // debug statements here
21603 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
21605 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
21606 if(!isWasmInitialized) {
21607 throw new Error("initializeWasm() must be awaited first!");
21609 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
21610 return nativeResponseValue;
21612 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21614 export function ChannelPublicKeys_set_htlc_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_htlc_basepoint(this_ptr, val);
21619 // debug statements here
21621 // 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);
21623 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 {
21624 if(!isWasmInitialized) {
21625 throw new Error("initializeWasm() must be awaited first!");
21627 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
21628 return nativeResponseValue;
21630 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
21632 export function ChannelPublicKeys_clone_ptr(arg: number): number {
21633 if(!isWasmInitialized) {
21634 throw new Error("initializeWasm() must be awaited first!");
21636 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
21637 return nativeResponseValue;
21639 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
21641 export function ChannelPublicKeys_clone(orig: number): number {
21642 if(!isWasmInitialized) {
21643 throw new Error("initializeWasm() must be awaited first!");
21645 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
21646 return nativeResponseValue;
21648 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
21650 export function ChannelPublicKeys_write(obj: number): number {
21651 if(!isWasmInitialized) {
21652 throw new Error("initializeWasm() must be awaited first!");
21654 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
21655 return nativeResponseValue;
21657 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
21659 export function ChannelPublicKeys_read(ser: number): number {
21660 if(!isWasmInitialized) {
21661 throw new Error("initializeWasm() must be awaited first!");
21663 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
21664 return nativeResponseValue;
21666 // 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);
21668 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 {
21669 if(!isWasmInitialized) {
21670 throw new Error("initializeWasm() must be awaited first!");
21672 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
21673 return nativeResponseValue;
21675 // 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);
21677 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
21678 if(!isWasmInitialized) {
21679 throw new Error("initializeWasm() must be awaited first!");
21681 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
21682 return nativeResponseValue;
21684 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
21686 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
21687 if(!isWasmInitialized) {
21688 throw new Error("initializeWasm() must be awaited first!");
21690 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
21691 return nativeResponseValue;
21693 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
21695 export function HTLCOutputInCommitment_free(this_obj: number): void {
21696 if(!isWasmInitialized) {
21697 throw new Error("initializeWasm() must be awaited first!");
21699 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
21700 // debug statements here
21702 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21704 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
21705 if(!isWasmInitialized) {
21706 throw new Error("initializeWasm() must be awaited first!");
21708 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
21709 return nativeResponseValue;
21711 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
21713 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
21714 if(!isWasmInitialized) {
21715 throw new Error("initializeWasm() must be awaited first!");
21717 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
21718 // debug statements here
21720 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21722 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
21723 if(!isWasmInitialized) {
21724 throw new Error("initializeWasm() must be awaited first!");
21726 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
21727 return nativeResponseValue;
21729 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
21731 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
21732 if(!isWasmInitialized) {
21733 throw new Error("initializeWasm() must be awaited first!");
21735 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
21736 // debug statements here
21738 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21740 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
21741 if(!isWasmInitialized) {
21742 throw new Error("initializeWasm() must be awaited first!");
21744 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
21745 return nativeResponseValue;
21747 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
21749 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
21750 if(!isWasmInitialized) {
21751 throw new Error("initializeWasm() must be awaited first!");
21753 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
21754 // debug statements here
21756 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
21758 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
21759 if(!isWasmInitialized) {
21760 throw new Error("initializeWasm() must be awaited first!");
21762 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
21763 return nativeResponseValue;
21765 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21767 export function HTLCOutputInCommitment_set_payment_hash(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_payment_hash(this_ptr, val);
21772 // debug statements here
21774 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
21776 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
21777 if(!isWasmInitialized) {
21778 throw new Error("initializeWasm() must be awaited first!");
21780 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
21781 return nativeResponseValue;
21783 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
21785 export function HTLCOutputInCommitment_set_transaction_output_index(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_transaction_output_index(this_ptr, val);
21790 // debug statements here
21792 // 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);
21794 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 {
21795 if(!isWasmInitialized) {
21796 throw new Error("initializeWasm() must be awaited first!");
21798 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
21799 return nativeResponseValue;
21801 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
21803 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
21804 if(!isWasmInitialized) {
21805 throw new Error("initializeWasm() must be awaited first!");
21807 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
21808 return nativeResponseValue;
21810 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
21812 export function HTLCOutputInCommitment_clone(orig: number): number {
21813 if(!isWasmInitialized) {
21814 throw new Error("initializeWasm() must be awaited first!");
21816 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
21817 return nativeResponseValue;
21819 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
21821 export function HTLCOutputInCommitment_write(obj: number): number {
21822 if(!isWasmInitialized) {
21823 throw new Error("initializeWasm() must be awaited first!");
21825 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
21826 return nativeResponseValue;
21828 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
21830 export function HTLCOutputInCommitment_read(ser: number): number {
21831 if(!isWasmInitialized) {
21832 throw new Error("initializeWasm() must be awaited first!");
21834 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
21835 return nativeResponseValue;
21837 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
21839 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
21840 if(!isWasmInitialized) {
21841 throw new Error("initializeWasm() must be awaited first!");
21843 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
21844 return nativeResponseValue;
21846 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
21848 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
21849 if(!isWasmInitialized) {
21850 throw new Error("initializeWasm() must be awaited first!");
21852 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
21853 return nativeResponseValue;
21855 // 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);
21857 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 {
21858 if(!isWasmInitialized) {
21859 throw new Error("initializeWasm() must be awaited first!");
21861 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
21862 return nativeResponseValue;
21864 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
21866 export function get_anchor_redeemscript(funding_pubkey: number): number {
21867 if(!isWasmInitialized) {
21868 throw new Error("initializeWasm() must be awaited first!");
21870 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
21871 return nativeResponseValue;
21873 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
21875 export function ChannelTransactionParameters_free(this_obj: number): void {
21876 if(!isWasmInitialized) {
21877 throw new Error("initializeWasm() must be awaited first!");
21879 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
21880 // debug statements here
21882 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21884 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
21885 if(!isWasmInitialized) {
21886 throw new Error("initializeWasm() must be awaited first!");
21888 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
21889 return nativeResponseValue;
21891 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
21893 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
21894 if(!isWasmInitialized) {
21895 throw new Error("initializeWasm() must be awaited first!");
21897 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
21898 // debug statements here
21900 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21902 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
21903 if(!isWasmInitialized) {
21904 throw new Error("initializeWasm() must be awaited first!");
21906 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
21907 return nativeResponseValue;
21909 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
21911 export function ChannelTransactionParameters_set_holder_selected_contest_delay(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_selected_contest_delay(this_ptr, val);
21916 // debug statements here
21918 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21920 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
21921 if(!isWasmInitialized) {
21922 throw new Error("initializeWasm() must be awaited first!");
21924 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
21925 return nativeResponseValue;
21927 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
21929 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
21930 if(!isWasmInitialized) {
21931 throw new Error("initializeWasm() must be awaited first!");
21933 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
21934 // debug statements here
21936 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21938 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
21939 if(!isWasmInitialized) {
21940 throw new Error("initializeWasm() must be awaited first!");
21942 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
21943 return nativeResponseValue;
21945 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
21947 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
21948 if(!isWasmInitialized) {
21949 throw new Error("initializeWasm() must be awaited first!");
21951 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
21952 // debug statements here
21954 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21956 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
21957 if(!isWasmInitialized) {
21958 throw new Error("initializeWasm() must be awaited first!");
21960 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
21961 return nativeResponseValue;
21963 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
21965 export function ChannelTransactionParameters_set_funding_outpoint(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_funding_outpoint(this_ptr, val);
21970 // debug statements here
21972 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
21974 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
21975 if(!isWasmInitialized) {
21976 throw new Error("initializeWasm() must be awaited first!");
21978 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
21979 return nativeResponseValue;
21981 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
21983 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
21984 if(!isWasmInitialized) {
21985 throw new Error("initializeWasm() must be awaited first!");
21987 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
21988 // debug statements here
21990 // 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);
21992 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 {
21993 if(!isWasmInitialized) {
21994 throw new Error("initializeWasm() must be awaited first!");
21996 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);
21997 return nativeResponseValue;
21999 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
22001 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
22002 if(!isWasmInitialized) {
22003 throw new Error("initializeWasm() must be awaited first!");
22005 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
22006 return nativeResponseValue;
22008 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
22010 export function ChannelTransactionParameters_clone(orig: number): number {
22011 if(!isWasmInitialized) {
22012 throw new Error("initializeWasm() must be awaited first!");
22014 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
22015 return nativeResponseValue;
22017 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
22019 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
22020 if(!isWasmInitialized) {
22021 throw new Error("initializeWasm() must be awaited first!");
22023 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
22024 // debug statements here
22026 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
22028 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
22029 if(!isWasmInitialized) {
22030 throw new Error("initializeWasm() must be awaited first!");
22032 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
22033 return nativeResponseValue;
22035 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
22037 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
22038 if(!isWasmInitialized) {
22039 throw new Error("initializeWasm() must be awaited first!");
22041 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
22042 // debug statements here
22044 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
22046 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
22047 if(!isWasmInitialized) {
22048 throw new Error("initializeWasm() must be awaited first!");
22050 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
22051 return nativeResponseValue;
22053 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
22055 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(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_selected_contest_delay(this_ptr, val);
22060 // debug statements here
22062 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
22064 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
22065 if(!isWasmInitialized) {
22066 throw new Error("initializeWasm() must be awaited first!");
22068 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
22069 return nativeResponseValue;
22071 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
22073 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
22074 if(!isWasmInitialized) {
22075 throw new Error("initializeWasm() must be awaited first!");
22077 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
22078 return nativeResponseValue;
22080 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
22082 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
22083 if(!isWasmInitialized) {
22084 throw new Error("initializeWasm() must be awaited first!");
22086 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
22087 return nativeResponseValue;
22089 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
22091 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
22092 if(!isWasmInitialized) {
22093 throw new Error("initializeWasm() must be awaited first!");
22095 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
22096 return nativeResponseValue;
22098 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
22100 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
22101 if(!isWasmInitialized) {
22102 throw new Error("initializeWasm() must be awaited first!");
22104 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
22105 return nativeResponseValue;
22107 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
22109 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
22110 if(!isWasmInitialized) {
22111 throw new Error("initializeWasm() must be awaited first!");
22113 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
22114 return nativeResponseValue;
22116 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
22118 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
22119 if(!isWasmInitialized) {
22120 throw new Error("initializeWasm() must be awaited first!");
22122 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
22123 return nativeResponseValue;
22125 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
22127 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
22128 if(!isWasmInitialized) {
22129 throw new Error("initializeWasm() must be awaited first!");
22131 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
22132 return nativeResponseValue;
22134 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
22136 export function ChannelTransactionParameters_write(obj: number): number {
22137 if(!isWasmInitialized) {
22138 throw new Error("initializeWasm() must be awaited first!");
22140 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
22141 return nativeResponseValue;
22143 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
22145 export function ChannelTransactionParameters_read(ser: number): number {
22146 if(!isWasmInitialized) {
22147 throw new Error("initializeWasm() must be awaited first!");
22149 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
22150 return nativeResponseValue;
22152 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
22154 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
22155 if(!isWasmInitialized) {
22156 throw new Error("initializeWasm() must be awaited first!");
22158 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
22159 // debug statements here
22161 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22163 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
22164 if(!isWasmInitialized) {
22165 throw new Error("initializeWasm() must be awaited first!");
22167 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
22168 return nativeResponseValue;
22170 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22172 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
22173 if(!isWasmInitialized) {
22174 throw new Error("initializeWasm() must be awaited first!");
22176 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
22177 return nativeResponseValue;
22179 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22181 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
22182 if(!isWasmInitialized) {
22183 throw new Error("initializeWasm() must be awaited first!");
22185 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
22186 return nativeResponseValue;
22188 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22190 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
22191 if(!isWasmInitialized) {
22192 throw new Error("initializeWasm() must be awaited first!");
22194 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
22195 return nativeResponseValue;
22197 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22199 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
22200 if(!isWasmInitialized) {
22201 throw new Error("initializeWasm() must be awaited first!");
22203 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
22204 return nativeResponseValue;
22206 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
22208 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
22209 if(!isWasmInitialized) {
22210 throw new Error("initializeWasm() must be awaited first!");
22212 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
22213 return nativeResponseValue;
22215 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
22217 export function HolderCommitmentTransaction_free(this_obj: number): void {
22218 if(!isWasmInitialized) {
22219 throw new Error("initializeWasm() must be awaited first!");
22221 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
22222 // debug statements here
22224 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
22226 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
22227 if(!isWasmInitialized) {
22228 throw new Error("initializeWasm() must be awaited first!");
22230 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
22231 return nativeResponseValue;
22233 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
22235 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
22236 if(!isWasmInitialized) {
22237 throw new Error("initializeWasm() must be awaited first!");
22239 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
22240 // debug statements here
22242 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22244 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
22245 if(!isWasmInitialized) {
22246 throw new Error("initializeWasm() must be awaited first!");
22248 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
22249 // debug statements here
22251 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
22253 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
22254 if(!isWasmInitialized) {
22255 throw new Error("initializeWasm() must be awaited first!");
22257 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
22258 return nativeResponseValue;
22260 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
22262 export function HolderCommitmentTransaction_clone(orig: number): number {
22263 if(!isWasmInitialized) {
22264 throw new Error("initializeWasm() must be awaited first!");
22266 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
22267 return nativeResponseValue;
22269 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
22271 export function HolderCommitmentTransaction_write(obj: number): number {
22272 if(!isWasmInitialized) {
22273 throw new Error("initializeWasm() must be awaited first!");
22275 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
22276 return nativeResponseValue;
22278 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
22280 export function HolderCommitmentTransaction_read(ser: number): number {
22281 if(!isWasmInitialized) {
22282 throw new Error("initializeWasm() must be awaited first!");
22284 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
22285 return nativeResponseValue;
22287 // 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);
22289 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
22290 if(!isWasmInitialized) {
22291 throw new Error("initializeWasm() must be awaited first!");
22293 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
22294 return nativeResponseValue;
22296 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
22298 export function BuiltCommitmentTransaction_free(this_obj: number): void {
22299 if(!isWasmInitialized) {
22300 throw new Error("initializeWasm() must be awaited first!");
22302 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
22303 // debug statements here
22305 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
22307 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
22308 if(!isWasmInitialized) {
22309 throw new Error("initializeWasm() must be awaited first!");
22311 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
22312 return nativeResponseValue;
22314 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
22316 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
22317 if(!isWasmInitialized) {
22318 throw new Error("initializeWasm() must be awaited first!");
22320 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
22321 // debug statements here
22323 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
22325 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
22326 if(!isWasmInitialized) {
22327 throw new Error("initializeWasm() must be awaited first!");
22329 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
22330 return nativeResponseValue;
22332 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22334 export function BuiltCommitmentTransaction_set_txid(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_txid(this_ptr, val);
22339 // debug statements here
22341 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
22343 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
22344 if(!isWasmInitialized) {
22345 throw new Error("initializeWasm() must be awaited first!");
22347 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
22348 return nativeResponseValue;
22350 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
22352 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
22353 if(!isWasmInitialized) {
22354 throw new Error("initializeWasm() must be awaited first!");
22356 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
22357 return nativeResponseValue;
22359 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
22361 export function BuiltCommitmentTransaction_clone(orig: number): number {
22362 if(!isWasmInitialized) {
22363 throw new Error("initializeWasm() must be awaited first!");
22365 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
22366 return nativeResponseValue;
22368 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
22370 export function BuiltCommitmentTransaction_write(obj: number): number {
22371 if(!isWasmInitialized) {
22372 throw new Error("initializeWasm() must be awaited first!");
22374 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
22375 return nativeResponseValue;
22377 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
22379 export function BuiltCommitmentTransaction_read(ser: number): number {
22380 if(!isWasmInitialized) {
22381 throw new Error("initializeWasm() must be awaited first!");
22383 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
22384 return nativeResponseValue;
22386 // 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);
22388 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22389 if(!isWasmInitialized) {
22390 throw new Error("initializeWasm() must be awaited first!");
22392 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
22393 return nativeResponseValue;
22395 // 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);
22397 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22398 if(!isWasmInitialized) {
22399 throw new Error("initializeWasm() must be awaited first!");
22401 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
22402 return nativeResponseValue;
22404 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
22406 export function ClosingTransaction_free(this_obj: number): void {
22407 if(!isWasmInitialized) {
22408 throw new Error("initializeWasm() must be awaited first!");
22410 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
22411 // debug statements here
22413 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
22415 export function ClosingTransaction_clone_ptr(arg: number): number {
22416 if(!isWasmInitialized) {
22417 throw new Error("initializeWasm() must be awaited first!");
22419 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
22420 return nativeResponseValue;
22422 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
22424 export function ClosingTransaction_clone(orig: number): number {
22425 if(!isWasmInitialized) {
22426 throw new Error("initializeWasm() must be awaited first!");
22428 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
22429 return nativeResponseValue;
22431 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
22433 export function ClosingTransaction_hash(o: number): bigint {
22434 if(!isWasmInitialized) {
22435 throw new Error("initializeWasm() must be awaited first!");
22437 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
22438 return nativeResponseValue;
22440 // 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);
22442 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 {
22443 if(!isWasmInitialized) {
22444 throw new Error("initializeWasm() must be awaited first!");
22446 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
22447 return nativeResponseValue;
22449 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22451 export function ClosingTransaction_trust(this_arg: number): number {
22452 if(!isWasmInitialized) {
22453 throw new Error("initializeWasm() must be awaited first!");
22455 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
22456 return nativeResponseValue;
22458 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
22460 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
22461 if(!isWasmInitialized) {
22462 throw new Error("initializeWasm() must be awaited first!");
22464 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
22465 return nativeResponseValue;
22467 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22469 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
22470 if(!isWasmInitialized) {
22471 throw new Error("initializeWasm() must be awaited first!");
22473 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
22474 return nativeResponseValue;
22476 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22478 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
22479 if(!isWasmInitialized) {
22480 throw new Error("initializeWasm() must be awaited first!");
22482 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
22483 return nativeResponseValue;
22485 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22487 export function ClosingTransaction_to_holder_script(this_arg: number): number {
22488 if(!isWasmInitialized) {
22489 throw new Error("initializeWasm() must be awaited first!");
22491 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
22492 return nativeResponseValue;
22494 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
22496 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
22497 if(!isWasmInitialized) {
22498 throw new Error("initializeWasm() must be awaited first!");
22500 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
22501 return nativeResponseValue;
22503 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
22505 export function TrustedClosingTransaction_free(this_obj: number): void {
22506 if(!isWasmInitialized) {
22507 throw new Error("initializeWasm() must be awaited first!");
22509 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
22510 // debug statements here
22512 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
22514 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
22515 if(!isWasmInitialized) {
22516 throw new Error("initializeWasm() must be awaited first!");
22518 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
22519 return nativeResponseValue;
22521 // 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);
22523 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22524 if(!isWasmInitialized) {
22525 throw new Error("initializeWasm() must be awaited first!");
22527 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
22528 return nativeResponseValue;
22530 // 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);
22532 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
22533 if(!isWasmInitialized) {
22534 throw new Error("initializeWasm() must be awaited first!");
22536 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
22537 return nativeResponseValue;
22539 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
22541 export function CommitmentTransaction_free(this_obj: number): void {
22542 if(!isWasmInitialized) {
22543 throw new Error("initializeWasm() must be awaited first!");
22545 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
22546 // debug statements here
22548 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
22550 export function CommitmentTransaction_clone_ptr(arg: number): number {
22551 if(!isWasmInitialized) {
22552 throw new Error("initializeWasm() must be awaited first!");
22554 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
22555 return nativeResponseValue;
22557 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
22559 export function CommitmentTransaction_clone(orig: number): number {
22560 if(!isWasmInitialized) {
22561 throw new Error("initializeWasm() must be awaited first!");
22563 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
22564 return nativeResponseValue;
22566 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
22568 export function CommitmentTransaction_write(obj: number): number {
22569 if(!isWasmInitialized) {
22570 throw new Error("initializeWasm() must be awaited first!");
22572 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
22573 return nativeResponseValue;
22575 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
22577 export function CommitmentTransaction_read(ser: number): number {
22578 if(!isWasmInitialized) {
22579 throw new Error("initializeWasm() must be awaited first!");
22581 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
22582 return nativeResponseValue;
22584 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22586 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
22587 if(!isWasmInitialized) {
22588 throw new Error("initializeWasm() must be awaited first!");
22590 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
22591 return nativeResponseValue;
22593 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22595 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
22596 if(!isWasmInitialized) {
22597 throw new Error("initializeWasm() must be awaited first!");
22599 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
22600 return nativeResponseValue;
22602 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22604 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
22605 if(!isWasmInitialized) {
22606 throw new Error("initializeWasm() must be awaited first!");
22608 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
22609 return nativeResponseValue;
22611 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22613 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
22614 if(!isWasmInitialized) {
22615 throw new Error("initializeWasm() must be awaited first!");
22617 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
22618 return nativeResponseValue;
22620 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
22622 export function CommitmentTransaction_trust(this_arg: number): number {
22623 if(!isWasmInitialized) {
22624 throw new Error("initializeWasm() must be awaited first!");
22626 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
22627 return nativeResponseValue;
22629 // 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);
22631 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
22632 if(!isWasmInitialized) {
22633 throw new Error("initializeWasm() must be awaited first!");
22635 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
22636 return nativeResponseValue;
22638 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
22640 export function TrustedCommitmentTransaction_free(this_obj: number): void {
22641 if(!isWasmInitialized) {
22642 throw new Error("initializeWasm() must be awaited first!");
22644 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
22645 // debug statements here
22647 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22649 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
22650 if(!isWasmInitialized) {
22651 throw new Error("initializeWasm() must be awaited first!");
22653 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
22654 return nativeResponseValue;
22656 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22658 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
22659 if(!isWasmInitialized) {
22660 throw new Error("initializeWasm() must be awaited first!");
22662 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
22663 return nativeResponseValue;
22665 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22667 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
22668 if(!isWasmInitialized) {
22669 throw new Error("initializeWasm() must be awaited first!");
22671 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
22672 return nativeResponseValue;
22674 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
22676 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
22677 if(!isWasmInitialized) {
22678 throw new Error("initializeWasm() must be awaited first!");
22680 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
22681 return nativeResponseValue;
22683 // 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);
22685 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
22686 if(!isWasmInitialized) {
22687 throw new Error("initializeWasm() must be awaited first!");
22689 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
22690 return nativeResponseValue;
22692 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
22694 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
22695 if(!isWasmInitialized) {
22696 throw new Error("initializeWasm() must be awaited first!");
22698 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
22699 return nativeResponseValue;
22701 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
22703 export function InitFeatures_eq(a: number, b: number): boolean {
22704 if(!isWasmInitialized) {
22705 throw new Error("initializeWasm() must be awaited first!");
22707 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
22708 return nativeResponseValue;
22710 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
22712 export function NodeFeatures_eq(a: number, b: number): boolean {
22713 if(!isWasmInitialized) {
22714 throw new Error("initializeWasm() must be awaited first!");
22716 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
22717 return nativeResponseValue;
22719 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
22721 export function ChannelFeatures_eq(a: number, b: number): boolean {
22722 if(!isWasmInitialized) {
22723 throw new Error("initializeWasm() must be awaited first!");
22725 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
22726 return nativeResponseValue;
22728 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
22730 export function InvoiceFeatures_eq(a: number, b: number): boolean {
22731 if(!isWasmInitialized) {
22732 throw new Error("initializeWasm() must be awaited first!");
22734 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
22735 return nativeResponseValue;
22737 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
22739 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
22740 if(!isWasmInitialized) {
22741 throw new Error("initializeWasm() must be awaited first!");
22743 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
22744 return nativeResponseValue;
22746 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
22748 export function InitFeatures_clone_ptr(arg: number): number {
22749 if(!isWasmInitialized) {
22750 throw new Error("initializeWasm() must be awaited first!");
22752 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
22753 return nativeResponseValue;
22755 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
22757 export function InitFeatures_clone(orig: number): number {
22758 if(!isWasmInitialized) {
22759 throw new Error("initializeWasm() must be awaited first!");
22761 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
22762 return nativeResponseValue;
22764 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
22766 export function NodeFeatures_clone_ptr(arg: number): number {
22767 if(!isWasmInitialized) {
22768 throw new Error("initializeWasm() must be awaited first!");
22770 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
22771 return nativeResponseValue;
22773 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
22775 export function NodeFeatures_clone(orig: number): number {
22776 if(!isWasmInitialized) {
22777 throw new Error("initializeWasm() must be awaited first!");
22779 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
22780 return nativeResponseValue;
22782 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
22784 export function ChannelFeatures_clone_ptr(arg: number): number {
22785 if(!isWasmInitialized) {
22786 throw new Error("initializeWasm() must be awaited first!");
22788 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
22789 return nativeResponseValue;
22791 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
22793 export function ChannelFeatures_clone(orig: number): number {
22794 if(!isWasmInitialized) {
22795 throw new Error("initializeWasm() must be awaited first!");
22797 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
22798 return nativeResponseValue;
22800 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
22802 export function InvoiceFeatures_clone_ptr(arg: number): number {
22803 if(!isWasmInitialized) {
22804 throw new Error("initializeWasm() must be awaited first!");
22806 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
22807 return nativeResponseValue;
22809 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
22811 export function InvoiceFeatures_clone(orig: number): number {
22812 if(!isWasmInitialized) {
22813 throw new Error("initializeWasm() must be awaited first!");
22815 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
22816 return nativeResponseValue;
22818 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
22820 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
22821 if(!isWasmInitialized) {
22822 throw new Error("initializeWasm() must be awaited first!");
22824 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
22825 return nativeResponseValue;
22827 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
22829 export function ChannelTypeFeatures_clone(orig: number): number {
22830 if(!isWasmInitialized) {
22831 throw new Error("initializeWasm() must be awaited first!");
22833 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
22834 return nativeResponseValue;
22836 // void InitFeatures_free(struct LDKInitFeatures this_obj);
22838 export function InitFeatures_free(this_obj: number): void {
22839 if(!isWasmInitialized) {
22840 throw new Error("initializeWasm() must be awaited first!");
22842 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
22843 // debug statements here
22845 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
22847 export function NodeFeatures_free(this_obj: number): void {
22848 if(!isWasmInitialized) {
22849 throw new Error("initializeWasm() must be awaited first!");
22851 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
22852 // debug statements here
22854 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
22856 export function ChannelFeatures_free(this_obj: number): void {
22857 if(!isWasmInitialized) {
22858 throw new Error("initializeWasm() must be awaited first!");
22860 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
22861 // debug statements here
22863 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
22865 export function InvoiceFeatures_free(this_obj: number): void {
22866 if(!isWasmInitialized) {
22867 throw new Error("initializeWasm() must be awaited first!");
22869 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
22870 // debug statements here
22872 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
22874 export function ChannelTypeFeatures_free(this_obj: number): void {
22875 if(!isWasmInitialized) {
22876 throw new Error("initializeWasm() must be awaited first!");
22878 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
22879 // debug statements here
22881 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
22883 export function InitFeatures_empty(): number {
22884 if(!isWasmInitialized) {
22885 throw new Error("initializeWasm() must be awaited first!");
22887 const nativeResponseValue = wasm.TS_InitFeatures_empty();
22888 return nativeResponseValue;
22890 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
22892 export function InitFeatures_known(): number {
22893 if(!isWasmInitialized) {
22894 throw new Error("initializeWasm() must be awaited first!");
22896 const nativeResponseValue = wasm.TS_InitFeatures_known();
22897 return nativeResponseValue;
22899 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
22901 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
22902 if(!isWasmInitialized) {
22903 throw new Error("initializeWasm() must be awaited first!");
22905 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
22906 return nativeResponseValue;
22908 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
22910 export function NodeFeatures_empty(): number {
22911 if(!isWasmInitialized) {
22912 throw new Error("initializeWasm() must be awaited first!");
22914 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
22915 return nativeResponseValue;
22917 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
22919 export function NodeFeatures_known(): number {
22920 if(!isWasmInitialized) {
22921 throw new Error("initializeWasm() must be awaited first!");
22923 const nativeResponseValue = wasm.TS_NodeFeatures_known();
22924 return nativeResponseValue;
22926 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
22928 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
22929 if(!isWasmInitialized) {
22930 throw new Error("initializeWasm() must be awaited first!");
22932 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
22933 return nativeResponseValue;
22935 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
22937 export function ChannelFeatures_empty(): number {
22938 if(!isWasmInitialized) {
22939 throw new Error("initializeWasm() must be awaited first!");
22941 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
22942 return nativeResponseValue;
22944 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
22946 export function ChannelFeatures_known(): number {
22947 if(!isWasmInitialized) {
22948 throw new Error("initializeWasm() must be awaited first!");
22950 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
22951 return nativeResponseValue;
22953 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
22955 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
22956 if(!isWasmInitialized) {
22957 throw new Error("initializeWasm() must be awaited first!");
22959 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
22960 return nativeResponseValue;
22962 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
22964 export function InvoiceFeatures_empty(): number {
22965 if(!isWasmInitialized) {
22966 throw new Error("initializeWasm() must be awaited first!");
22968 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
22969 return nativeResponseValue;
22971 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
22973 export function InvoiceFeatures_known(): number {
22974 if(!isWasmInitialized) {
22975 throw new Error("initializeWasm() must be awaited first!");
22977 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
22978 return nativeResponseValue;
22980 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
22982 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
22983 if(!isWasmInitialized) {
22984 throw new Error("initializeWasm() must be awaited first!");
22986 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
22987 return nativeResponseValue;
22989 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
22991 export function ChannelTypeFeatures_empty(): number {
22992 if(!isWasmInitialized) {
22993 throw new Error("initializeWasm() must be awaited first!");
22995 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
22996 return nativeResponseValue;
22998 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
23000 export function ChannelTypeFeatures_known(): number {
23001 if(!isWasmInitialized) {
23002 throw new Error("initializeWasm() must be awaited first!");
23004 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
23005 return nativeResponseValue;
23007 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
23009 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
23010 if(!isWasmInitialized) {
23011 throw new Error("initializeWasm() must be awaited first!");
23013 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
23014 return nativeResponseValue;
23016 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
23018 export function InitFeatures_write(obj: number): number {
23019 if(!isWasmInitialized) {
23020 throw new Error("initializeWasm() must be awaited first!");
23022 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
23023 return nativeResponseValue;
23025 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
23027 export function InitFeatures_read(ser: number): number {
23028 if(!isWasmInitialized) {
23029 throw new Error("initializeWasm() must be awaited first!");
23031 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
23032 return nativeResponseValue;
23034 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
23036 export function ChannelFeatures_write(obj: number): number {
23037 if(!isWasmInitialized) {
23038 throw new Error("initializeWasm() must be awaited first!");
23040 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
23041 return nativeResponseValue;
23043 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
23045 export function ChannelFeatures_read(ser: number): number {
23046 if(!isWasmInitialized) {
23047 throw new Error("initializeWasm() must be awaited first!");
23049 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
23050 return nativeResponseValue;
23052 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
23054 export function NodeFeatures_write(obj: number): number {
23055 if(!isWasmInitialized) {
23056 throw new Error("initializeWasm() must be awaited first!");
23058 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
23059 return nativeResponseValue;
23061 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
23063 export function NodeFeatures_read(ser: number): number {
23064 if(!isWasmInitialized) {
23065 throw new Error("initializeWasm() must be awaited first!");
23067 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
23068 return nativeResponseValue;
23070 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
23072 export function InvoiceFeatures_write(obj: number): number {
23073 if(!isWasmInitialized) {
23074 throw new Error("initializeWasm() must be awaited first!");
23076 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
23077 return nativeResponseValue;
23079 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
23081 export function InvoiceFeatures_read(ser: number): number {
23082 if(!isWasmInitialized) {
23083 throw new Error("initializeWasm() must be awaited first!");
23085 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
23086 return nativeResponseValue;
23088 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
23090 export function ChannelTypeFeatures_write(obj: number): number {
23091 if(!isWasmInitialized) {
23092 throw new Error("initializeWasm() must be awaited first!");
23094 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
23095 return nativeResponseValue;
23097 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
23099 export function ChannelTypeFeatures_read(ser: number): number {
23100 if(!isWasmInitialized) {
23101 throw new Error("initializeWasm() must be awaited first!");
23103 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
23104 return nativeResponseValue;
23106 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
23108 export function ShutdownScript_free(this_obj: number): void {
23109 if(!isWasmInitialized) {
23110 throw new Error("initializeWasm() must be awaited first!");
23112 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
23113 // debug statements here
23115 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
23117 export function ShutdownScript_clone_ptr(arg: number): number {
23118 if(!isWasmInitialized) {
23119 throw new Error("initializeWasm() must be awaited first!");
23121 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
23122 return nativeResponseValue;
23124 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
23126 export function ShutdownScript_clone(orig: number): number {
23127 if(!isWasmInitialized) {
23128 throw new Error("initializeWasm() must be awaited first!");
23130 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
23131 return nativeResponseValue;
23133 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
23135 export function InvalidShutdownScript_free(this_obj: number): void {
23136 if(!isWasmInitialized) {
23137 throw new Error("initializeWasm() must be awaited first!");
23139 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
23140 // debug statements here
23142 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
23144 export function InvalidShutdownScript_get_script(this_ptr: number): number {
23145 if(!isWasmInitialized) {
23146 throw new Error("initializeWasm() must be awaited first!");
23148 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
23149 return nativeResponseValue;
23151 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23153 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
23154 if(!isWasmInitialized) {
23155 throw new Error("initializeWasm() must be awaited first!");
23157 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
23158 // debug statements here
23160 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
23162 export function InvalidShutdownScript_new(script_arg: number): number {
23163 if(!isWasmInitialized) {
23164 throw new Error("initializeWasm() must be awaited first!");
23166 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
23167 return nativeResponseValue;
23169 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
23171 export function InvalidShutdownScript_clone_ptr(arg: number): number {
23172 if(!isWasmInitialized) {
23173 throw new Error("initializeWasm() must be awaited first!");
23175 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
23176 return nativeResponseValue;
23178 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
23180 export function InvalidShutdownScript_clone(orig: number): number {
23181 if(!isWasmInitialized) {
23182 throw new Error("initializeWasm() must be awaited first!");
23184 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
23185 return nativeResponseValue;
23187 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
23189 export function ShutdownScript_write(obj: number): number {
23190 if(!isWasmInitialized) {
23191 throw new Error("initializeWasm() must be awaited first!");
23193 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
23194 return nativeResponseValue;
23196 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
23198 export function ShutdownScript_read(ser: number): number {
23199 if(!isWasmInitialized) {
23200 throw new Error("initializeWasm() must be awaited first!");
23202 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
23203 return nativeResponseValue;
23205 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
23207 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
23208 if(!isWasmInitialized) {
23209 throw new Error("initializeWasm() must be awaited first!");
23211 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
23212 return nativeResponseValue;
23214 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
23216 export function ShutdownScript_new_p2wsh(script_hash: number): number {
23217 if(!isWasmInitialized) {
23218 throw new Error("initializeWasm() must be awaited first!");
23220 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
23221 return nativeResponseValue;
23223 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(uint8_t version, struct LDKu8slice program);
23225 export function ShutdownScript_new_witness_program(version: number, program: number): number {
23226 if(!isWasmInitialized) {
23227 throw new Error("initializeWasm() must be awaited first!");
23229 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
23230 return nativeResponseValue;
23232 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
23234 export function ShutdownScript_into_inner(this_arg: number): number {
23235 if(!isWasmInitialized) {
23236 throw new Error("initializeWasm() must be awaited first!");
23238 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
23239 return nativeResponseValue;
23241 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
23243 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
23244 if(!isWasmInitialized) {
23245 throw new Error("initializeWasm() must be awaited first!");
23247 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
23248 return nativeResponseValue;
23250 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
23252 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
23253 if(!isWasmInitialized) {
23254 throw new Error("initializeWasm() must be awaited first!");
23256 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
23257 return nativeResponseValue;
23259 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
23261 export function CustomMessageReader_free(this_ptr: number): void {
23262 if(!isWasmInitialized) {
23263 throw new Error("initializeWasm() must be awaited first!");
23265 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
23266 // debug statements here
23268 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
23270 export function Type_clone_ptr(arg: number): number {
23271 if(!isWasmInitialized) {
23272 throw new Error("initializeWasm() must be awaited first!");
23274 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
23275 return nativeResponseValue;
23277 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
23279 export function Type_clone(orig: number): number {
23280 if(!isWasmInitialized) {
23281 throw new Error("initializeWasm() must be awaited first!");
23283 const nativeResponseValue = wasm.TS_Type_clone(orig);
23284 return nativeResponseValue;
23286 // void Type_free(struct LDKType this_ptr);
23288 export function Type_free(this_ptr: number): void {
23289 if(!isWasmInitialized) {
23290 throw new Error("initializeWasm() must be awaited first!");
23292 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
23293 // debug statements here
23295 // void NodeId_free(struct LDKNodeId this_obj);
23297 export function NodeId_free(this_obj: number): void {
23298 if(!isWasmInitialized) {
23299 throw new Error("initializeWasm() must be awaited first!");
23301 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
23302 // debug statements here
23304 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
23306 export function NodeId_clone_ptr(arg: number): number {
23307 if(!isWasmInitialized) {
23308 throw new Error("initializeWasm() must be awaited first!");
23310 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
23311 return nativeResponseValue;
23313 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
23315 export function NodeId_clone(orig: number): number {
23316 if(!isWasmInitialized) {
23317 throw new Error("initializeWasm() must be awaited first!");
23319 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
23320 return nativeResponseValue;
23322 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
23324 export function NodeId_from_pubkey(pubkey: number): number {
23325 if(!isWasmInitialized) {
23326 throw new Error("initializeWasm() must be awaited first!");
23328 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
23329 return nativeResponseValue;
23331 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
23333 export function NodeId_as_slice(this_arg: number): number {
23334 if(!isWasmInitialized) {
23335 throw new Error("initializeWasm() must be awaited first!");
23337 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
23338 return nativeResponseValue;
23340 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
23342 export function NodeId_hash(o: number): bigint {
23343 if(!isWasmInitialized) {
23344 throw new Error("initializeWasm() must be awaited first!");
23346 const nativeResponseValue = wasm.TS_NodeId_hash(o);
23347 return nativeResponseValue;
23349 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
23351 export function NodeId_write(obj: number): number {
23352 if(!isWasmInitialized) {
23353 throw new Error("initializeWasm() must be awaited first!");
23355 const nativeResponseValue = wasm.TS_NodeId_write(obj);
23356 return nativeResponseValue;
23358 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
23360 export function NodeId_read(ser: number): number {
23361 if(!isWasmInitialized) {
23362 throw new Error("initializeWasm() must be awaited first!");
23364 const nativeResponseValue = wasm.TS_NodeId_read(ser);
23365 return nativeResponseValue;
23367 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
23369 export function NetworkGraph_free(this_obj: number): void {
23370 if(!isWasmInitialized) {
23371 throw new Error("initializeWasm() must be awaited first!");
23373 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
23374 // debug statements here
23376 // uintptr_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
23378 export function NetworkGraph_clone_ptr(arg: number): number {
23379 if(!isWasmInitialized) {
23380 throw new Error("initializeWasm() must be awaited first!");
23382 const nativeResponseValue = wasm.TS_NetworkGraph_clone_ptr(arg);
23383 return nativeResponseValue;
23385 // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
23387 export function NetworkGraph_clone(orig: number): number {
23388 if(!isWasmInitialized) {
23389 throw new Error("initializeWasm() must be awaited first!");
23391 const nativeResponseValue = wasm.TS_NetworkGraph_clone(orig);
23392 return nativeResponseValue;
23394 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
23396 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
23397 if(!isWasmInitialized) {
23398 throw new Error("initializeWasm() must be awaited first!");
23400 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
23401 // debug statements here
23403 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
23405 export function NetworkUpdate_free(this_ptr: number): void {
23406 if(!isWasmInitialized) {
23407 throw new Error("initializeWasm() must be awaited first!");
23409 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
23410 // debug statements here
23412 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
23414 export function NetworkUpdate_clone_ptr(arg: number): number {
23415 if(!isWasmInitialized) {
23416 throw new Error("initializeWasm() must be awaited first!");
23418 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
23419 return nativeResponseValue;
23421 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
23423 export function NetworkUpdate_clone(orig: number): number {
23424 if(!isWasmInitialized) {
23425 throw new Error("initializeWasm() must be awaited first!");
23427 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
23428 return nativeResponseValue;
23430 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
23432 export function NetworkUpdate_channel_update_message(msg: number): number {
23433 if(!isWasmInitialized) {
23434 throw new Error("initializeWasm() must be awaited first!");
23436 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
23437 return nativeResponseValue;
23439 // struct LDKNetworkUpdate NetworkUpdate_channel_closed(uint64_t short_channel_id, bool is_permanent);
23441 export function NetworkUpdate_channel_closed(short_channel_id: bigint, is_permanent: boolean): number {
23442 if(!isWasmInitialized) {
23443 throw new Error("initializeWasm() must be awaited first!");
23445 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_closed(short_channel_id, is_permanent);
23446 return nativeResponseValue;
23448 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
23450 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
23451 if(!isWasmInitialized) {
23452 throw new Error("initializeWasm() must be awaited first!");
23454 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
23455 return nativeResponseValue;
23457 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
23459 export function NetworkUpdate_write(obj: number): number {
23460 if(!isWasmInitialized) {
23461 throw new Error("initializeWasm() must be awaited first!");
23463 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
23464 return nativeResponseValue;
23466 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
23468 export function NetworkUpdate_read(ser: number): number {
23469 if(!isWasmInitialized) {
23470 throw new Error("initializeWasm() must be awaited first!");
23472 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
23473 return nativeResponseValue;
23475 // struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
23477 export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
23478 if(!isWasmInitialized) {
23479 throw new Error("initializeWasm() must be awaited first!");
23481 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_EventHandler(this_arg);
23482 return nativeResponseValue;
23484 // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
23486 export function NetGraphMsgHandler_free(this_obj: number): void {
23487 if(!isWasmInitialized) {
23488 throw new Error("initializeWasm() must be awaited first!");
23490 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_free(this_obj);
23491 // debug statements here
23493 // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
23495 export function NetGraphMsgHandler_new(network_graph: number, chain_access: number, logger: number): number {
23496 if(!isWasmInitialized) {
23497 throw new Error("initializeWasm() must be awaited first!");
23499 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_new(network_graph, chain_access, logger);
23500 return nativeResponseValue;
23502 // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
23504 export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
23505 if(!isWasmInitialized) {
23506 throw new Error("initializeWasm() must be awaited first!");
23508 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
23509 // debug statements here
23511 // struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
23513 export function NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: number): number {
23514 if(!isWasmInitialized) {
23515 throw new Error("initializeWasm() must be awaited first!");
23517 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_RoutingMessageHandler(this_arg);
23518 return nativeResponseValue;
23520 // struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
23522 export function NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg: number): number {
23523 if(!isWasmInitialized) {
23524 throw new Error("initializeWasm() must be awaited first!");
23526 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg);
23527 return nativeResponseValue;
23529 // void DirectionalChannelInfo_free(struct LDKDirectionalChannelInfo this_obj);
23531 export function DirectionalChannelInfo_free(this_obj: number): void {
23532 if(!isWasmInitialized) {
23533 throw new Error("initializeWasm() must be awaited first!");
23535 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_free(this_obj);
23536 // debug statements here
23538 // uint32_t DirectionalChannelInfo_get_last_update(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23540 export function DirectionalChannelInfo_get_last_update(this_ptr: number): number {
23541 if(!isWasmInitialized) {
23542 throw new Error("initializeWasm() must be awaited first!");
23544 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_last_update(this_ptr);
23545 return nativeResponseValue;
23547 // void DirectionalChannelInfo_set_last_update(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint32_t val);
23549 export function DirectionalChannelInfo_set_last_update(this_ptr: number, val: number): void {
23550 if(!isWasmInitialized) {
23551 throw new Error("initializeWasm() must be awaited first!");
23553 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_last_update(this_ptr, val);
23554 // debug statements here
23556 // bool DirectionalChannelInfo_get_enabled(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23558 export function DirectionalChannelInfo_get_enabled(this_ptr: number): boolean {
23559 if(!isWasmInitialized) {
23560 throw new Error("initializeWasm() must be awaited first!");
23562 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_enabled(this_ptr);
23563 return nativeResponseValue;
23565 // void DirectionalChannelInfo_set_enabled(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, bool val);
23567 export function DirectionalChannelInfo_set_enabled(this_ptr: number, val: boolean): void {
23568 if(!isWasmInitialized) {
23569 throw new Error("initializeWasm() must be awaited first!");
23571 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_enabled(this_ptr, val);
23572 // debug statements here
23574 // uint16_t DirectionalChannelInfo_get_cltv_expiry_delta(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23576 export function DirectionalChannelInfo_get_cltv_expiry_delta(this_ptr: number): number {
23577 if(!isWasmInitialized) {
23578 throw new Error("initializeWasm() must be awaited first!");
23580 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_cltv_expiry_delta(this_ptr);
23581 return nativeResponseValue;
23583 // void DirectionalChannelInfo_set_cltv_expiry_delta(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint16_t val);
23585 export function DirectionalChannelInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23586 if(!isWasmInitialized) {
23587 throw new Error("initializeWasm() must be awaited first!");
23589 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_cltv_expiry_delta(this_ptr, val);
23590 // debug statements here
23592 // uint64_t DirectionalChannelInfo_get_htlc_minimum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23594 export function DirectionalChannelInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
23595 if(!isWasmInitialized) {
23596 throw new Error("initializeWasm() must be awaited first!");
23598 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_htlc_minimum_msat(this_ptr);
23599 return nativeResponseValue;
23601 // void DirectionalChannelInfo_set_htlc_minimum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, uint64_t val);
23603 export function DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23604 if(!isWasmInitialized) {
23605 throw new Error("initializeWasm() must be awaited first!");
23607 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr, val);
23608 // debug statements here
23610 // struct LDKCOption_u64Z DirectionalChannelInfo_get_htlc_maximum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23612 export function DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr: number): number {
23613 if(!isWasmInitialized) {
23614 throw new Error("initializeWasm() must be awaited first!");
23616 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr);
23617 return nativeResponseValue;
23619 // void DirectionalChannelInfo_set_htlc_maximum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
23621 export function DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
23622 if(!isWasmInitialized) {
23623 throw new Error("initializeWasm() must be awaited first!");
23625 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr, val);
23626 // debug statements here
23628 // struct LDKRoutingFees DirectionalChannelInfo_get_fees(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23630 export function DirectionalChannelInfo_get_fees(this_ptr: number): number {
23631 if(!isWasmInitialized) {
23632 throw new Error("initializeWasm() must be awaited first!");
23634 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_fees(this_ptr);
23635 return nativeResponseValue;
23637 // void DirectionalChannelInfo_set_fees(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
23639 export function DirectionalChannelInfo_set_fees(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_fees(this_ptr, val);
23644 // debug statements here
23646 // struct LDKChannelUpdate DirectionalChannelInfo_get_last_update_message(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
23648 export function DirectionalChannelInfo_get_last_update_message(this_ptr: number): number {
23649 if(!isWasmInitialized) {
23650 throw new Error("initializeWasm() must be awaited first!");
23652 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_get_last_update_message(this_ptr);
23653 return nativeResponseValue;
23655 // void DirectionalChannelInfo_set_last_update_message(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
23657 export function DirectionalChannelInfo_set_last_update_message(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_last_update_message(this_ptr, val);
23662 // debug statements here
23664 // 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);
23666 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 {
23667 if(!isWasmInitialized) {
23668 throw new Error("initializeWasm() must be awaited first!");
23670 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);
23671 return nativeResponseValue;
23673 // uintptr_t DirectionalChannelInfo_clone_ptr(LDKDirectionalChannelInfo *NONNULL_PTR arg);
23675 export function DirectionalChannelInfo_clone_ptr(arg: number): number {
23676 if(!isWasmInitialized) {
23677 throw new Error("initializeWasm() must be awaited first!");
23679 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_clone_ptr(arg);
23680 return nativeResponseValue;
23682 // struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
23684 export function DirectionalChannelInfo_clone(orig: number): number {
23685 if(!isWasmInitialized) {
23686 throw new Error("initializeWasm() must be awaited first!");
23688 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_clone(orig);
23689 return nativeResponseValue;
23691 // struct LDKCVec_u8Z DirectionalChannelInfo_write(const struct LDKDirectionalChannelInfo *NONNULL_PTR obj);
23693 export function DirectionalChannelInfo_write(obj: number): number {
23694 if(!isWasmInitialized) {
23695 throw new Error("initializeWasm() must be awaited first!");
23697 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_write(obj);
23698 return nativeResponseValue;
23700 // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ DirectionalChannelInfo_read(struct LDKu8slice ser);
23702 export function DirectionalChannelInfo_read(ser: number): number {
23703 if(!isWasmInitialized) {
23704 throw new Error("initializeWasm() must be awaited first!");
23706 const nativeResponseValue = wasm.TS_DirectionalChannelInfo_read(ser);
23707 return nativeResponseValue;
23709 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
23711 export function ChannelInfo_free(this_obj: number): void {
23712 if(!isWasmInitialized) {
23713 throw new Error("initializeWasm() must be awaited first!");
23715 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
23716 // debug statements here
23718 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23720 export function ChannelInfo_get_features(this_ptr: number): number {
23721 if(!isWasmInitialized) {
23722 throw new Error("initializeWasm() must be awaited first!");
23724 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
23725 return nativeResponseValue;
23727 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
23729 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
23730 if(!isWasmInitialized) {
23731 throw new Error("initializeWasm() must be awaited first!");
23733 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
23734 // debug statements here
23736 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23738 export function ChannelInfo_get_node_one(this_ptr: number): number {
23739 if(!isWasmInitialized) {
23740 throw new Error("initializeWasm() must be awaited first!");
23742 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
23743 return nativeResponseValue;
23745 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
23747 export function ChannelInfo_set_node_one(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_node_one(this_ptr, val);
23752 // debug statements here
23754 // struct LDKDirectionalChannelInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23756 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
23757 if(!isWasmInitialized) {
23758 throw new Error("initializeWasm() must be awaited first!");
23760 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
23761 return nativeResponseValue;
23763 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
23765 export function ChannelInfo_set_one_to_two(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_one_to_two(this_ptr, val);
23770 // debug statements here
23772 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23774 export function ChannelInfo_get_node_two(this_ptr: number): number {
23775 if(!isWasmInitialized) {
23776 throw new Error("initializeWasm() must be awaited first!");
23778 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
23779 return nativeResponseValue;
23781 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
23783 export function ChannelInfo_set_node_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_node_two(this_ptr, val);
23788 // debug statements here
23790 // struct LDKDirectionalChannelInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23792 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
23793 if(!isWasmInitialized) {
23794 throw new Error("initializeWasm() must be awaited first!");
23796 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
23797 return nativeResponseValue;
23799 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKDirectionalChannelInfo val);
23801 export function ChannelInfo_set_two_to_one(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_two_to_one(this_ptr, val);
23806 // debug statements here
23808 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23810 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
23811 if(!isWasmInitialized) {
23812 throw new Error("initializeWasm() must be awaited first!");
23814 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
23815 return nativeResponseValue;
23817 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
23819 export function ChannelInfo_set_capacity_sats(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_capacity_sats(this_ptr, val);
23824 // debug statements here
23826 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
23828 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
23829 if(!isWasmInitialized) {
23830 throw new Error("initializeWasm() must be awaited first!");
23832 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
23833 return nativeResponseValue;
23835 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
23837 export function ChannelInfo_set_announcement_message(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_announcement_message(this_ptr, val);
23842 // debug statements here
23844 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
23846 export function ChannelInfo_clone_ptr(arg: number): number {
23847 if(!isWasmInitialized) {
23848 throw new Error("initializeWasm() must be awaited first!");
23850 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
23851 return nativeResponseValue;
23853 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
23855 export function ChannelInfo_clone(orig: number): number {
23856 if(!isWasmInitialized) {
23857 throw new Error("initializeWasm() must be awaited first!");
23859 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
23860 return nativeResponseValue;
23862 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
23864 export function ChannelInfo_write(obj: number): number {
23865 if(!isWasmInitialized) {
23866 throw new Error("initializeWasm() must be awaited first!");
23868 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
23869 return nativeResponseValue;
23871 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
23873 export function ChannelInfo_read(ser: number): number {
23874 if(!isWasmInitialized) {
23875 throw new Error("initializeWasm() must be awaited first!");
23877 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
23878 return nativeResponseValue;
23880 // void RoutingFees_free(struct LDKRoutingFees this_obj);
23882 export function RoutingFees_free(this_obj: number): void {
23883 if(!isWasmInitialized) {
23884 throw new Error("initializeWasm() must be awaited first!");
23886 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
23887 // debug statements here
23889 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
23891 export function RoutingFees_get_base_msat(this_ptr: number): number {
23892 if(!isWasmInitialized) {
23893 throw new Error("initializeWasm() must be awaited first!");
23895 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
23896 return nativeResponseValue;
23898 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
23900 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
23901 if(!isWasmInitialized) {
23902 throw new Error("initializeWasm() must be awaited first!");
23904 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
23905 // debug statements here
23907 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
23909 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
23910 if(!isWasmInitialized) {
23911 throw new Error("initializeWasm() must be awaited first!");
23913 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
23914 return nativeResponseValue;
23916 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
23918 export function RoutingFees_set_proportional_millionths(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_proportional_millionths(this_ptr, val);
23923 // debug statements here
23925 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
23927 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
23928 if(!isWasmInitialized) {
23929 throw new Error("initializeWasm() must be awaited first!");
23931 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
23932 return nativeResponseValue;
23934 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
23936 export function RoutingFees_eq(a: number, b: number): boolean {
23937 if(!isWasmInitialized) {
23938 throw new Error("initializeWasm() must be awaited first!");
23940 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
23941 return nativeResponseValue;
23943 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
23945 export function RoutingFees_clone_ptr(arg: number): number {
23946 if(!isWasmInitialized) {
23947 throw new Error("initializeWasm() must be awaited first!");
23949 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
23950 return nativeResponseValue;
23952 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
23954 export function RoutingFees_clone(orig: number): number {
23955 if(!isWasmInitialized) {
23956 throw new Error("initializeWasm() must be awaited first!");
23958 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
23959 return nativeResponseValue;
23961 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
23963 export function RoutingFees_hash(o: number): bigint {
23964 if(!isWasmInitialized) {
23965 throw new Error("initializeWasm() must be awaited first!");
23967 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
23968 return nativeResponseValue;
23970 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
23972 export function RoutingFees_write(obj: number): number {
23973 if(!isWasmInitialized) {
23974 throw new Error("initializeWasm() must be awaited first!");
23976 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
23977 return nativeResponseValue;
23979 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
23981 export function RoutingFees_read(ser: number): number {
23982 if(!isWasmInitialized) {
23983 throw new Error("initializeWasm() must be awaited first!");
23985 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
23986 return nativeResponseValue;
23988 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
23990 export function NodeAnnouncementInfo_free(this_obj: number): void {
23991 if(!isWasmInitialized) {
23992 throw new Error("initializeWasm() must be awaited first!");
23994 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
23995 // debug statements here
23997 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
23999 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
24000 if(!isWasmInitialized) {
24001 throw new Error("initializeWasm() must be awaited first!");
24003 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
24004 return nativeResponseValue;
24006 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
24008 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
24009 if(!isWasmInitialized) {
24010 throw new Error("initializeWasm() must be awaited first!");
24012 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
24013 // debug statements here
24015 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
24017 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
24018 if(!isWasmInitialized) {
24019 throw new Error("initializeWasm() must be awaited first!");
24021 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
24022 return nativeResponseValue;
24024 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
24026 export function NodeAnnouncementInfo_set_last_update(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_last_update(this_ptr, val);
24031 // debug statements here
24033 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
24035 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
24036 if(!isWasmInitialized) {
24037 throw new Error("initializeWasm() must be awaited first!");
24039 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
24040 return nativeResponseValue;
24042 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
24044 export function NodeAnnouncementInfo_set_rgb(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_rgb(this_ptr, val);
24049 // debug statements here
24051 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
24053 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
24054 if(!isWasmInitialized) {
24055 throw new Error("initializeWasm() must be awaited first!");
24057 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
24058 return nativeResponseValue;
24060 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24062 export function NodeAnnouncementInfo_set_alias(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_alias(this_ptr, val);
24067 // debug statements here
24069 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
24071 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
24072 if(!isWasmInitialized) {
24073 throw new Error("initializeWasm() must be awaited first!");
24075 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
24076 // debug statements here
24078 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
24080 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
24081 if(!isWasmInitialized) {
24082 throw new Error("initializeWasm() must be awaited first!");
24084 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
24085 return nativeResponseValue;
24087 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
24089 export function NodeAnnouncementInfo_set_announcement_message(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_announcement_message(this_ptr, val);
24094 // debug statements here
24096 // 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);
24098 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 {
24099 if(!isWasmInitialized) {
24100 throw new Error("initializeWasm() must be awaited first!");
24102 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
24103 return nativeResponseValue;
24105 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
24107 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
24108 if(!isWasmInitialized) {
24109 throw new Error("initializeWasm() must be awaited first!");
24111 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
24112 return nativeResponseValue;
24114 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
24116 export function NodeAnnouncementInfo_clone(orig: number): number {
24117 if(!isWasmInitialized) {
24118 throw new Error("initializeWasm() must be awaited first!");
24120 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
24121 return nativeResponseValue;
24123 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
24125 export function NodeAnnouncementInfo_write(obj: number): number {
24126 if(!isWasmInitialized) {
24127 throw new Error("initializeWasm() must be awaited first!");
24129 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
24130 return nativeResponseValue;
24132 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
24134 export function NodeAnnouncementInfo_read(ser: number): number {
24135 if(!isWasmInitialized) {
24136 throw new Error("initializeWasm() must be awaited first!");
24138 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
24139 return nativeResponseValue;
24141 // void NodeInfo_free(struct LDKNodeInfo this_obj);
24143 export function NodeInfo_free(this_obj: number): void {
24144 if(!isWasmInitialized) {
24145 throw new Error("initializeWasm() must be awaited first!");
24147 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
24148 // debug statements here
24150 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24152 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
24153 if(!isWasmInitialized) {
24154 throw new Error("initializeWasm() must be awaited first!");
24156 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
24157 // debug statements here
24159 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
24161 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
24162 if(!isWasmInitialized) {
24163 throw new Error("initializeWasm() must be awaited first!");
24165 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
24166 return nativeResponseValue;
24168 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
24170 export function NodeInfo_set_lowest_inbound_channel_fees(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_lowest_inbound_channel_fees(this_ptr, val);
24175 // debug statements here
24177 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
24179 export function NodeInfo_get_announcement_info(this_ptr: number): number {
24180 if(!isWasmInitialized) {
24181 throw new Error("initializeWasm() must be awaited first!");
24183 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
24184 return nativeResponseValue;
24186 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
24188 export function NodeInfo_set_announcement_info(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_announcement_info(this_ptr, val);
24193 // debug statements here
24195 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
24197 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
24198 if(!isWasmInitialized) {
24199 throw new Error("initializeWasm() must be awaited first!");
24201 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
24202 return nativeResponseValue;
24204 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
24206 export function NodeInfo_clone_ptr(arg: number): number {
24207 if(!isWasmInitialized) {
24208 throw new Error("initializeWasm() must be awaited first!");
24210 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
24211 return nativeResponseValue;
24213 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
24215 export function NodeInfo_clone(orig: number): number {
24216 if(!isWasmInitialized) {
24217 throw new Error("initializeWasm() must be awaited first!");
24219 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
24220 return nativeResponseValue;
24222 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
24224 export function NodeInfo_write(obj: number): number {
24225 if(!isWasmInitialized) {
24226 throw new Error("initializeWasm() must be awaited first!");
24228 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
24229 return nativeResponseValue;
24231 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
24233 export function NodeInfo_read(ser: number): number {
24234 if(!isWasmInitialized) {
24235 throw new Error("initializeWasm() must be awaited first!");
24237 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
24238 return nativeResponseValue;
24240 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
24242 export function NetworkGraph_write(obj: number): number {
24243 if(!isWasmInitialized) {
24244 throw new Error("initializeWasm() must be awaited first!");
24246 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
24247 return nativeResponseValue;
24249 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
24251 export function NetworkGraph_read(ser: number): number {
24252 if(!isWasmInitialized) {
24253 throw new Error("initializeWasm() must be awaited first!");
24255 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser);
24256 return nativeResponseValue;
24258 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
24260 export function NetworkGraph_new(genesis_hash: number): number {
24261 if(!isWasmInitialized) {
24262 throw new Error("initializeWasm() must be awaited first!");
24264 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash);
24265 return nativeResponseValue;
24267 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
24269 export function NetworkGraph_read_only(this_arg: number): number {
24270 if(!isWasmInitialized) {
24271 throw new Error("initializeWasm() must be awaited first!");
24273 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
24274 return nativeResponseValue;
24276 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
24278 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
24279 if(!isWasmInitialized) {
24280 throw new Error("initializeWasm() must be awaited first!");
24282 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
24283 return nativeResponseValue;
24285 // 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);
24287 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
24288 if(!isWasmInitialized) {
24289 throw new Error("initializeWasm() must be awaited first!");
24291 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
24292 return nativeResponseValue;
24294 // 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);
24296 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
24297 if(!isWasmInitialized) {
24298 throw new Error("initializeWasm() must be awaited first!");
24300 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
24301 return nativeResponseValue;
24303 // 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);
24305 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
24306 if(!isWasmInitialized) {
24307 throw new Error("initializeWasm() must be awaited first!");
24309 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
24310 return nativeResponseValue;
24312 // void NetworkGraph_close_channel_from_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
24314 export function NetworkGraph_close_channel_from_update(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
24315 if(!isWasmInitialized) {
24316 throw new Error("initializeWasm() must be awaited first!");
24318 const nativeResponseValue = wasm.TS_NetworkGraph_close_channel_from_update(this_arg, short_channel_id, is_permanent);
24319 // debug statements here
24321 // void NetworkGraph_fail_node(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
24323 export function NetworkGraph_fail_node(this_arg: number, _node_id: number, is_permanent: boolean): void {
24324 if(!isWasmInitialized) {
24325 throw new Error("initializeWasm() must be awaited first!");
24327 const nativeResponseValue = wasm.TS_NetworkGraph_fail_node(this_arg, _node_id, is_permanent);
24328 // debug statements here
24330 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
24332 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
24333 if(!isWasmInitialized) {
24334 throw new Error("initializeWasm() must be awaited first!");
24336 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
24337 // debug statements here
24339 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
24341 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
24342 if(!isWasmInitialized) {
24343 throw new Error("initializeWasm() must be awaited first!");
24345 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
24346 return nativeResponseValue;
24348 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
24350 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
24351 if(!isWasmInitialized) {
24352 throw new Error("initializeWasm() must be awaited first!");
24354 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
24355 return nativeResponseValue;
24357 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
24359 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
24360 if(!isWasmInitialized) {
24361 throw new Error("initializeWasm() must be awaited first!");
24363 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
24364 return nativeResponseValue;
24366 // void RouteHop_free(struct LDKRouteHop this_obj);
24368 export function RouteHop_free(this_obj: number): void {
24369 if(!isWasmInitialized) {
24370 throw new Error("initializeWasm() must be awaited first!");
24372 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
24373 // debug statements here
24375 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24377 export function RouteHop_get_pubkey(this_ptr: number): number {
24378 if(!isWasmInitialized) {
24379 throw new Error("initializeWasm() must be awaited first!");
24381 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
24382 return nativeResponseValue;
24384 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24386 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
24387 if(!isWasmInitialized) {
24388 throw new Error("initializeWasm() must be awaited first!");
24390 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
24391 // debug statements here
24393 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24395 export function RouteHop_get_node_features(this_ptr: number): number {
24396 if(!isWasmInitialized) {
24397 throw new Error("initializeWasm() must be awaited first!");
24399 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
24400 return nativeResponseValue;
24402 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
24404 export function RouteHop_set_node_features(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_node_features(this_ptr, val);
24409 // debug statements here
24411 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24413 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
24414 if(!isWasmInitialized) {
24415 throw new Error("initializeWasm() must be awaited first!");
24417 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
24418 return nativeResponseValue;
24420 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
24422 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
24423 if(!isWasmInitialized) {
24424 throw new Error("initializeWasm() must be awaited first!");
24426 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
24427 // debug statements here
24429 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24431 export function RouteHop_get_channel_features(this_ptr: number): number {
24432 if(!isWasmInitialized) {
24433 throw new Error("initializeWasm() must be awaited first!");
24435 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
24436 return nativeResponseValue;
24438 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
24440 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
24441 if(!isWasmInitialized) {
24442 throw new Error("initializeWasm() must be awaited first!");
24444 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
24445 // debug statements here
24447 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24449 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
24450 if(!isWasmInitialized) {
24451 throw new Error("initializeWasm() must be awaited first!");
24453 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
24454 return nativeResponseValue;
24456 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
24458 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
24459 if(!isWasmInitialized) {
24460 throw new Error("initializeWasm() must be awaited first!");
24462 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
24463 // debug statements here
24465 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
24467 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
24468 if(!isWasmInitialized) {
24469 throw new Error("initializeWasm() must be awaited first!");
24471 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
24472 return nativeResponseValue;
24474 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
24476 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
24477 if(!isWasmInitialized) {
24478 throw new Error("initializeWasm() must be awaited first!");
24480 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
24481 // debug statements here
24483 // 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);
24485 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 {
24486 if(!isWasmInitialized) {
24487 throw new Error("initializeWasm() must be awaited first!");
24489 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);
24490 return nativeResponseValue;
24492 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
24494 export function RouteHop_clone_ptr(arg: number): number {
24495 if(!isWasmInitialized) {
24496 throw new Error("initializeWasm() must be awaited first!");
24498 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
24499 return nativeResponseValue;
24501 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
24503 export function RouteHop_clone(orig: number): number {
24504 if(!isWasmInitialized) {
24505 throw new Error("initializeWasm() must be awaited first!");
24507 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
24508 return nativeResponseValue;
24510 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
24512 export function RouteHop_hash(o: number): bigint {
24513 if(!isWasmInitialized) {
24514 throw new Error("initializeWasm() must be awaited first!");
24516 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
24517 return nativeResponseValue;
24519 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
24521 export function RouteHop_eq(a: number, b: number): boolean {
24522 if(!isWasmInitialized) {
24523 throw new Error("initializeWasm() must be awaited first!");
24525 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
24526 return nativeResponseValue;
24528 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
24530 export function RouteHop_write(obj: number): number {
24531 if(!isWasmInitialized) {
24532 throw new Error("initializeWasm() must be awaited first!");
24534 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
24535 return nativeResponseValue;
24537 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
24539 export function RouteHop_read(ser: number): number {
24540 if(!isWasmInitialized) {
24541 throw new Error("initializeWasm() must be awaited first!");
24543 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
24544 return nativeResponseValue;
24546 // void Route_free(struct LDKRoute this_obj);
24548 export function Route_free(this_obj: number): void {
24549 if(!isWasmInitialized) {
24550 throw new Error("initializeWasm() must be awaited first!");
24552 const nativeResponseValue = wasm.TS_Route_free(this_obj);
24553 // debug statements here
24555 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
24557 export function Route_get_paths(this_ptr: number): number {
24558 if(!isWasmInitialized) {
24559 throw new Error("initializeWasm() must be awaited first!");
24561 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
24562 return nativeResponseValue;
24564 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
24566 export function Route_set_paths(this_ptr: number, val: number): void {
24567 if(!isWasmInitialized) {
24568 throw new Error("initializeWasm() must be awaited first!");
24570 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
24571 // debug statements here
24573 // struct LDKPayee Route_get_payee(const struct LDKRoute *NONNULL_PTR this_ptr);
24575 export function Route_get_payee(this_ptr: number): number {
24576 if(!isWasmInitialized) {
24577 throw new Error("initializeWasm() must be awaited first!");
24579 const nativeResponseValue = wasm.TS_Route_get_payee(this_ptr);
24580 return nativeResponseValue;
24582 // void Route_set_payee(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPayee val);
24584 export function Route_set_payee(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_payee(this_ptr, val);
24589 // debug statements here
24591 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPayee payee_arg);
24593 export function Route_new(paths_arg: number, payee_arg: number): number {
24594 if(!isWasmInitialized) {
24595 throw new Error("initializeWasm() must be awaited first!");
24597 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payee_arg);
24598 return nativeResponseValue;
24600 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
24602 export function Route_clone_ptr(arg: number): number {
24603 if(!isWasmInitialized) {
24604 throw new Error("initializeWasm() must be awaited first!");
24606 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
24607 return nativeResponseValue;
24609 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
24611 export function Route_clone(orig: number): number {
24612 if(!isWasmInitialized) {
24613 throw new Error("initializeWasm() must be awaited first!");
24615 const nativeResponseValue = wasm.TS_Route_clone(orig);
24616 return nativeResponseValue;
24618 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
24620 export function Route_hash(o: number): bigint {
24621 if(!isWasmInitialized) {
24622 throw new Error("initializeWasm() must be awaited first!");
24624 const nativeResponseValue = wasm.TS_Route_hash(o);
24625 return nativeResponseValue;
24627 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
24629 export function Route_eq(a: number, b: number): boolean {
24630 if(!isWasmInitialized) {
24631 throw new Error("initializeWasm() must be awaited first!");
24633 const nativeResponseValue = wasm.TS_Route_eq(a, b);
24634 return nativeResponseValue;
24636 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
24638 export function Route_get_total_fees(this_arg: number): bigint {
24639 if(!isWasmInitialized) {
24640 throw new Error("initializeWasm() must be awaited first!");
24642 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
24643 return nativeResponseValue;
24645 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
24647 export function Route_get_total_amount(this_arg: number): bigint {
24648 if(!isWasmInitialized) {
24649 throw new Error("initializeWasm() must be awaited first!");
24651 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
24652 return nativeResponseValue;
24654 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
24656 export function Route_write(obj: number): number {
24657 if(!isWasmInitialized) {
24658 throw new Error("initializeWasm() must be awaited first!");
24660 const nativeResponseValue = wasm.TS_Route_write(obj);
24661 return nativeResponseValue;
24663 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
24665 export function Route_read(ser: number): number {
24666 if(!isWasmInitialized) {
24667 throw new Error("initializeWasm() must be awaited first!");
24669 const nativeResponseValue = wasm.TS_Route_read(ser);
24670 return nativeResponseValue;
24672 // void RouteParameters_free(struct LDKRouteParameters this_obj);
24674 export function RouteParameters_free(this_obj: number): void {
24675 if(!isWasmInitialized) {
24676 throw new Error("initializeWasm() must be awaited first!");
24678 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
24679 // debug statements here
24681 // struct LDKPayee RouteParameters_get_payee(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
24683 export function RouteParameters_get_payee(this_ptr: number): number {
24684 if(!isWasmInitialized) {
24685 throw new Error("initializeWasm() must be awaited first!");
24687 const nativeResponseValue = wasm.TS_RouteParameters_get_payee(this_ptr);
24688 return nativeResponseValue;
24690 // void RouteParameters_set_payee(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPayee val);
24692 export function RouteParameters_set_payee(this_ptr: number, val: number): void {
24693 if(!isWasmInitialized) {
24694 throw new Error("initializeWasm() must be awaited first!");
24696 const nativeResponseValue = wasm.TS_RouteParameters_set_payee(this_ptr, val);
24697 // debug statements here
24699 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
24701 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
24702 if(!isWasmInitialized) {
24703 throw new Error("initializeWasm() must be awaited first!");
24705 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
24706 return nativeResponseValue;
24708 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
24710 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
24711 if(!isWasmInitialized) {
24712 throw new Error("initializeWasm() must be awaited first!");
24714 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
24715 // debug statements here
24717 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
24719 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
24720 if(!isWasmInitialized) {
24721 throw new Error("initializeWasm() must be awaited first!");
24723 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
24724 return nativeResponseValue;
24726 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
24728 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
24729 if(!isWasmInitialized) {
24730 throw new Error("initializeWasm() must be awaited first!");
24732 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
24733 // debug statements here
24735 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPayee payee_arg, uint64_t final_value_msat_arg, uint32_t final_cltv_expiry_delta_arg);
24737 export function RouteParameters_new(payee_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
24738 if(!isWasmInitialized) {
24739 throw new Error("initializeWasm() must be awaited first!");
24741 const nativeResponseValue = wasm.TS_RouteParameters_new(payee_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
24742 return nativeResponseValue;
24744 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
24746 export function RouteParameters_clone_ptr(arg: number): number {
24747 if(!isWasmInitialized) {
24748 throw new Error("initializeWasm() must be awaited first!");
24750 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
24751 return nativeResponseValue;
24753 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
24755 export function RouteParameters_clone(orig: number): number {
24756 if(!isWasmInitialized) {
24757 throw new Error("initializeWasm() must be awaited first!");
24759 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
24760 return nativeResponseValue;
24762 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
24764 export function RouteParameters_write(obj: number): number {
24765 if(!isWasmInitialized) {
24766 throw new Error("initializeWasm() must be awaited first!");
24768 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
24769 return nativeResponseValue;
24771 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
24773 export function RouteParameters_read(ser: number): number {
24774 if(!isWasmInitialized) {
24775 throw new Error("initializeWasm() must be awaited first!");
24777 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
24778 return nativeResponseValue;
24780 // void Payee_free(struct LDKPayee this_obj);
24782 export function Payee_free(this_obj: number): void {
24783 if(!isWasmInitialized) {
24784 throw new Error("initializeWasm() must be awaited first!");
24786 const nativeResponseValue = wasm.TS_Payee_free(this_obj);
24787 // debug statements here
24789 // struct LDKPublicKey Payee_get_pubkey(const struct LDKPayee *NONNULL_PTR this_ptr);
24791 export function Payee_get_pubkey(this_ptr: number): number {
24792 if(!isWasmInitialized) {
24793 throw new Error("initializeWasm() must be awaited first!");
24795 const nativeResponseValue = wasm.TS_Payee_get_pubkey(this_ptr);
24796 return nativeResponseValue;
24798 // void Payee_set_pubkey(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24800 export function Payee_set_pubkey(this_ptr: number, val: number): void {
24801 if(!isWasmInitialized) {
24802 throw new Error("initializeWasm() must be awaited first!");
24804 const nativeResponseValue = wasm.TS_Payee_set_pubkey(this_ptr, val);
24805 // debug statements here
24807 // struct LDKInvoiceFeatures Payee_get_features(const struct LDKPayee *NONNULL_PTR this_ptr);
24809 export function Payee_get_features(this_ptr: number): number {
24810 if(!isWasmInitialized) {
24811 throw new Error("initializeWasm() must be awaited first!");
24813 const nativeResponseValue = wasm.TS_Payee_get_features(this_ptr);
24814 return nativeResponseValue;
24816 // void Payee_set_features(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
24818 export function Payee_set_features(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_features(this_ptr, val);
24823 // debug statements here
24825 // struct LDKCVec_RouteHintZ Payee_get_route_hints(const struct LDKPayee *NONNULL_PTR this_ptr);
24827 export function Payee_get_route_hints(this_ptr: number): number {
24828 if(!isWasmInitialized) {
24829 throw new Error("initializeWasm() must be awaited first!");
24831 const nativeResponseValue = wasm.TS_Payee_get_route_hints(this_ptr);
24832 return nativeResponseValue;
24834 // void Payee_set_route_hints(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
24836 export function Payee_set_route_hints(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_route_hints(this_ptr, val);
24841 // debug statements here
24843 // struct LDKCOption_u64Z Payee_get_expiry_time(const struct LDKPayee *NONNULL_PTR this_ptr);
24845 export function Payee_get_expiry_time(this_ptr: number): number {
24846 if(!isWasmInitialized) {
24847 throw new Error("initializeWasm() must be awaited first!");
24849 const nativeResponseValue = wasm.TS_Payee_get_expiry_time(this_ptr);
24850 return nativeResponseValue;
24852 // void Payee_set_expiry_time(struct LDKPayee *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
24854 export function Payee_set_expiry_time(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_expiry_time(this_ptr, val);
24859 // debug statements here
24861 // 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);
24863 export function Payee_new(pubkey_arg: number, features_arg: number, route_hints_arg: number, expiry_time_arg: number): number {
24864 if(!isWasmInitialized) {
24865 throw new Error("initializeWasm() must be awaited first!");
24867 const nativeResponseValue = wasm.TS_Payee_new(pubkey_arg, features_arg, route_hints_arg, expiry_time_arg);
24868 return nativeResponseValue;
24870 // uintptr_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg);
24872 export function Payee_clone_ptr(arg: number): number {
24873 if(!isWasmInitialized) {
24874 throw new Error("initializeWasm() must be awaited first!");
24876 const nativeResponseValue = wasm.TS_Payee_clone_ptr(arg);
24877 return nativeResponseValue;
24879 // struct LDKPayee Payee_clone(const struct LDKPayee *NONNULL_PTR orig);
24881 export function Payee_clone(orig: number): number {
24882 if(!isWasmInitialized) {
24883 throw new Error("initializeWasm() must be awaited first!");
24885 const nativeResponseValue = wasm.TS_Payee_clone(orig);
24886 return nativeResponseValue;
24888 // uint64_t Payee_hash(const struct LDKPayee *NONNULL_PTR o);
24890 export function Payee_hash(o: number): bigint {
24891 if(!isWasmInitialized) {
24892 throw new Error("initializeWasm() must be awaited first!");
24894 const nativeResponseValue = wasm.TS_Payee_hash(o);
24895 return nativeResponseValue;
24897 // bool Payee_eq(const struct LDKPayee *NONNULL_PTR a, const struct LDKPayee *NONNULL_PTR b);
24899 export function Payee_eq(a: number, b: number): boolean {
24900 if(!isWasmInitialized) {
24901 throw new Error("initializeWasm() must be awaited first!");
24903 const nativeResponseValue = wasm.TS_Payee_eq(a, b);
24904 return nativeResponseValue;
24906 // struct LDKCVec_u8Z Payee_write(const struct LDKPayee *NONNULL_PTR obj);
24908 export function Payee_write(obj: number): number {
24909 if(!isWasmInitialized) {
24910 throw new Error("initializeWasm() must be awaited first!");
24912 const nativeResponseValue = wasm.TS_Payee_write(obj);
24913 return nativeResponseValue;
24915 // struct LDKCResult_PayeeDecodeErrorZ Payee_read(struct LDKu8slice ser);
24917 export function Payee_read(ser: number): number {
24918 if(!isWasmInitialized) {
24919 throw new Error("initializeWasm() must be awaited first!");
24921 const nativeResponseValue = wasm.TS_Payee_read(ser);
24922 return nativeResponseValue;
24924 // MUST_USE_RES struct LDKPayee Payee_from_node_id(struct LDKPublicKey pubkey);
24926 export function Payee_from_node_id(pubkey: number): number {
24927 if(!isWasmInitialized) {
24928 throw new Error("initializeWasm() must be awaited first!");
24930 const nativeResponseValue = wasm.TS_Payee_from_node_id(pubkey);
24931 return nativeResponseValue;
24933 // MUST_USE_RES struct LDKPayee Payee_for_keysend(struct LDKPublicKey pubkey);
24935 export function Payee_for_keysend(pubkey: number): number {
24936 if(!isWasmInitialized) {
24937 throw new Error("initializeWasm() must be awaited first!");
24939 const nativeResponseValue = wasm.TS_Payee_for_keysend(pubkey);
24940 return nativeResponseValue;
24942 // void RouteHint_free(struct LDKRouteHint this_obj);
24944 export function RouteHint_free(this_obj: number): void {
24945 if(!isWasmInitialized) {
24946 throw new Error("initializeWasm() must be awaited first!");
24948 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
24949 // debug statements here
24951 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
24953 export function RouteHint_get_a(this_ptr: number): number {
24954 if(!isWasmInitialized) {
24955 throw new Error("initializeWasm() must be awaited first!");
24957 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
24958 return nativeResponseValue;
24960 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
24962 export function RouteHint_set_a(this_ptr: number, val: number): void {
24963 if(!isWasmInitialized) {
24964 throw new Error("initializeWasm() must be awaited first!");
24966 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
24967 // debug statements here
24969 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
24971 export function RouteHint_new(a_arg: number): number {
24972 if(!isWasmInitialized) {
24973 throw new Error("initializeWasm() must be awaited first!");
24975 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
24976 return nativeResponseValue;
24978 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
24980 export function RouteHint_clone_ptr(arg: number): number {
24981 if(!isWasmInitialized) {
24982 throw new Error("initializeWasm() must be awaited first!");
24984 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
24985 return nativeResponseValue;
24987 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
24989 export function RouteHint_clone(orig: number): number {
24990 if(!isWasmInitialized) {
24991 throw new Error("initializeWasm() must be awaited first!");
24993 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
24994 return nativeResponseValue;
24996 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
24998 export function RouteHint_hash(o: number): bigint {
24999 if(!isWasmInitialized) {
25000 throw new Error("initializeWasm() must be awaited first!");
25002 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
25003 return nativeResponseValue;
25005 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
25007 export function RouteHint_eq(a: number, b: number): boolean {
25008 if(!isWasmInitialized) {
25009 throw new Error("initializeWasm() must be awaited first!");
25011 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
25012 return nativeResponseValue;
25014 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
25016 export function RouteHint_write(obj: number): number {
25017 if(!isWasmInitialized) {
25018 throw new Error("initializeWasm() must be awaited first!");
25020 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
25021 return nativeResponseValue;
25023 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
25025 export function RouteHint_read(ser: number): number {
25026 if(!isWasmInitialized) {
25027 throw new Error("initializeWasm() must be awaited first!");
25029 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
25030 return nativeResponseValue;
25032 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
25034 export function RouteHintHop_free(this_obj: number): void {
25035 if(!isWasmInitialized) {
25036 throw new Error("initializeWasm() must be awaited first!");
25038 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
25039 // debug statements here
25041 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25043 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
25044 if(!isWasmInitialized) {
25045 throw new Error("initializeWasm() must be awaited first!");
25047 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
25048 return nativeResponseValue;
25050 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25052 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
25053 if(!isWasmInitialized) {
25054 throw new Error("initializeWasm() must be awaited first!");
25056 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
25057 // debug statements here
25059 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25061 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
25062 if(!isWasmInitialized) {
25063 throw new Error("initializeWasm() must be awaited first!");
25065 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
25066 return nativeResponseValue;
25068 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
25070 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
25071 if(!isWasmInitialized) {
25072 throw new Error("initializeWasm() must be awaited first!");
25074 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
25075 // debug statements here
25077 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25079 export function RouteHintHop_get_fees(this_ptr: number): number {
25080 if(!isWasmInitialized) {
25081 throw new Error("initializeWasm() must be awaited first!");
25083 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
25084 return nativeResponseValue;
25086 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
25088 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
25089 if(!isWasmInitialized) {
25090 throw new Error("initializeWasm() must be awaited first!");
25092 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
25093 // debug statements here
25095 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25097 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
25098 if(!isWasmInitialized) {
25099 throw new Error("initializeWasm() must be awaited first!");
25101 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
25102 return nativeResponseValue;
25104 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
25106 export function RouteHintHop_set_cltv_expiry_delta(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_cltv_expiry_delta(this_ptr, val);
25111 // debug statements here
25113 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25115 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
25116 if(!isWasmInitialized) {
25117 throw new Error("initializeWasm() must be awaited first!");
25119 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
25120 return nativeResponseValue;
25122 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25124 export function RouteHintHop_set_htlc_minimum_msat(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_htlc_minimum_msat(this_ptr, val);
25129 // debug statements here
25131 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
25133 export function RouteHintHop_get_htlc_maximum_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_maximum_msat(this_ptr);
25138 return nativeResponseValue;
25140 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
25142 export function RouteHintHop_set_htlc_maximum_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_maximum_msat(this_ptr, val);
25147 // debug statements here
25149 // 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);
25151 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 {
25152 if(!isWasmInitialized) {
25153 throw new Error("initializeWasm() must be awaited first!");
25155 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);
25156 return nativeResponseValue;
25158 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
25160 export function RouteHintHop_clone_ptr(arg: number): number {
25161 if(!isWasmInitialized) {
25162 throw new Error("initializeWasm() must be awaited first!");
25164 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
25165 return nativeResponseValue;
25167 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
25169 export function RouteHintHop_clone(orig: number): number {
25170 if(!isWasmInitialized) {
25171 throw new Error("initializeWasm() must be awaited first!");
25173 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
25174 return nativeResponseValue;
25176 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
25178 export function RouteHintHop_hash(o: number): bigint {
25179 if(!isWasmInitialized) {
25180 throw new Error("initializeWasm() must be awaited first!");
25182 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
25183 return nativeResponseValue;
25185 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
25187 export function RouteHintHop_eq(a: number, b: number): boolean {
25188 if(!isWasmInitialized) {
25189 throw new Error("initializeWasm() must be awaited first!");
25191 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
25192 return nativeResponseValue;
25194 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
25196 export function RouteHintHop_write(obj: number): number {
25197 if(!isWasmInitialized) {
25198 throw new Error("initializeWasm() must be awaited first!");
25200 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
25201 return nativeResponseValue;
25203 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
25205 export function RouteHintHop_read(ser: number): number {
25206 if(!isWasmInitialized) {
25207 throw new Error("initializeWasm() must be awaited first!");
25209 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
25210 return nativeResponseValue;
25212 // 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);
25214 export function find_route(our_node_pubkey: number, params: number, network: number, first_hops: number, logger: number, scorer: number): number {
25215 if(!isWasmInitialized) {
25216 throw new Error("initializeWasm() must be awaited first!");
25218 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, params, network, first_hops, logger, scorer);
25219 return nativeResponseValue;
25221 // void Score_free(struct LDKScore this_ptr);
25223 export function Score_free(this_ptr: number): void {
25224 if(!isWasmInitialized) {
25225 throw new Error("initializeWasm() must be awaited first!");
25227 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
25228 // debug statements here
25230 // void LockableScore_free(struct LDKLockableScore this_ptr);
25232 export function LockableScore_free(this_ptr: number): void {
25233 if(!isWasmInitialized) {
25234 throw new Error("initializeWasm() must be awaited first!");
25236 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
25237 // debug statements here
25239 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
25241 export function MultiThreadedLockableScore_free(this_obj: number): void {
25242 if(!isWasmInitialized) {
25243 throw new Error("initializeWasm() must be awaited first!");
25245 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
25246 // debug statements here
25248 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
25250 export function MultiThreadedLockableScore_new(score: number): number {
25251 if(!isWasmInitialized) {
25252 throw new Error("initializeWasm() must be awaited first!");
25254 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
25255 return nativeResponseValue;
25257 // void ScoringParameters_free(struct LDKScoringParameters this_obj);
25259 export function ScoringParameters_free(this_obj: number): void {
25260 if(!isWasmInitialized) {
25261 throw new Error("initializeWasm() must be awaited first!");
25263 const nativeResponseValue = wasm.TS_ScoringParameters_free(this_obj);
25264 // debug statements here
25266 // uint64_t ScoringParameters_get_base_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25268 export function ScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
25269 if(!isWasmInitialized) {
25270 throw new Error("initializeWasm() must be awaited first!");
25272 const nativeResponseValue = wasm.TS_ScoringParameters_get_base_penalty_msat(this_ptr);
25273 return nativeResponseValue;
25275 // void ScoringParameters_set_base_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25277 export function ScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
25278 if(!isWasmInitialized) {
25279 throw new Error("initializeWasm() must be awaited first!");
25281 const nativeResponseValue = wasm.TS_ScoringParameters_set_base_penalty_msat(this_ptr, val);
25282 // debug statements here
25284 // uint64_t ScoringParameters_get_failure_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25286 export function ScoringParameters_get_failure_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_failure_penalty_msat(this_ptr);
25291 return nativeResponseValue;
25293 // void ScoringParameters_set_failure_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25295 export function ScoringParameters_set_failure_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_failure_penalty_msat(this_ptr, val);
25300 // debug statements here
25302 // uint16_t ScoringParameters_get_overuse_penalty_start_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25304 export function ScoringParameters_get_overuse_penalty_start_1024th(this_ptr: number): number {
25305 if(!isWasmInitialized) {
25306 throw new Error("initializeWasm() must be awaited first!");
25308 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_start_1024th(this_ptr);
25309 return nativeResponseValue;
25311 // void ScoringParameters_set_overuse_penalty_start_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint16_t val);
25313 export function ScoringParameters_set_overuse_penalty_start_1024th(this_ptr: number, val: number): void {
25314 if(!isWasmInitialized) {
25315 throw new Error("initializeWasm() must be awaited first!");
25317 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_start_1024th(this_ptr, val);
25318 // debug statements here
25320 // uint64_t ScoringParameters_get_overuse_penalty_msat_per_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25322 export function ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr: number): bigint {
25323 if(!isWasmInitialized) {
25324 throw new Error("initializeWasm() must be awaited first!");
25326 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr);
25327 return nativeResponseValue;
25329 // void ScoringParameters_set_overuse_penalty_msat_per_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25331 export function ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr: number, val: bigint): void {
25332 if(!isWasmInitialized) {
25333 throw new Error("initializeWasm() must be awaited first!");
25335 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr, val);
25336 // debug statements here
25338 // uint64_t ScoringParameters_get_failure_penalty_half_life(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
25340 export function ScoringParameters_get_failure_penalty_half_life(this_ptr: number): bigint {
25341 if(!isWasmInitialized) {
25342 throw new Error("initializeWasm() must be awaited first!");
25344 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_half_life(this_ptr);
25345 return nativeResponseValue;
25347 // void ScoringParameters_set_failure_penalty_half_life(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
25349 export function ScoringParameters_set_failure_penalty_half_life(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_failure_penalty_half_life(this_ptr, val);
25354 // debug statements here
25356 // 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);
25358 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 {
25359 if(!isWasmInitialized) {
25360 throw new Error("initializeWasm() must be awaited first!");
25362 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);
25363 return nativeResponseValue;
25365 // struct LDKCVec_u8Z ScoringParameters_write(const struct LDKScoringParameters *NONNULL_PTR obj);
25367 export function ScoringParameters_write(obj: number): number {
25368 if(!isWasmInitialized) {
25369 throw new Error("initializeWasm() must be awaited first!");
25371 const nativeResponseValue = wasm.TS_ScoringParameters_write(obj);
25372 return nativeResponseValue;
25374 // struct LDKCResult_ScoringParametersDecodeErrorZ ScoringParameters_read(struct LDKu8slice ser);
25376 export function ScoringParameters_read(ser: number): number {
25377 if(!isWasmInitialized) {
25378 throw new Error("initializeWasm() must be awaited first!");
25380 const nativeResponseValue = wasm.TS_ScoringParameters_read(ser);
25381 return nativeResponseValue;
25383 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_default(void);
25385 export function ScoringParameters_default(): number {
25386 if(!isWasmInitialized) {
25387 throw new Error("initializeWasm() must be awaited first!");
25389 const nativeResponseValue = wasm.TS_ScoringParameters_default();
25390 return nativeResponseValue;
25394 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) {
25395 const weak: WeakRef<object> = js_objs[obj_ptr];
25396 if (weak == null || weak == undefined) {
25397 console.error("Got function call on unknown/free'd JS object!");
25398 throw new Error("Got function call on unknown/free'd JS object!");
25400 const obj: object = weak.deref();
25401 if (obj == null || obj == undefined) {
25402 console.error("Got function call on GC'd JS object!");
25403 throw new Error("Got function call on GC'd JS object!");
25407 case 0: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
25408 case 1: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
25409 case 2: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
25410 case 3: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
25411 case 4: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
25412 case 5: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
25413 case 6: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
25414 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
25415 case 8: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
25416 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
25417 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
25418 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
25419 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
25420 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
25421 case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
25422 case 15: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
25423 case 16: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
25424 case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
25425 case 18: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
25426 case 19: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
25427 case 20: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
25428 case 21: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
25429 case 22: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
25430 case 23: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
25431 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
25432 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
25433 case 26: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
25434 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
25435 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
25436 case 29: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
25437 case 30: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
25438 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
25439 case 32: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
25440 case 33: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
25441 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
25442 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
25443 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
25444 case 37: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
25445 case 38: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
25446 case 39: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
25447 case 40: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
25448 case 41: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
25449 case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
25450 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
25451 case 44: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
25452 case 45: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
25453 case 46: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
25454 case 47: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
25455 case 48: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
25456 case 49: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_locked"); break;
25457 case 50: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
25458 case 51: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
25459 case 52: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
25460 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
25461 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
25462 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
25463 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
25464 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
25465 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
25466 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
25467 case 60: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
25468 case 61: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
25469 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
25470 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
25471 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
25472 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
25473 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
25474 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
25475 case 68: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
25476 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
25477 case 70: fn = Object.getOwnPropertyDescriptor(obj, "sync_routing_table"); break;
25478 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
25479 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
25480 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
25481 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
25482 case 75: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
25483 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
25484 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
25485 case 78: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
25486 case 79: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
25487 case 80: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
25488 case 81: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
25489 case 82: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
25490 case 83: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
25491 case 84: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
25492 case 85: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
25493 case 86: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
25495 console.error("Got unknown function call from C!");
25496 throw new Error("Got unknown function call from C!");
25498 if (fn == null || fn == undefined) {
25499 console.error("Got function call on incorrect JS object!");
25500 throw new Error("Got function call on incorrect JS object!");
25502 return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);