2 import * as version from './version.mjs';
3 import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
5 const imports: any = {};
8 var js_objs: Array<WeakRef<object>> = [];
9 var js_invoke: Function;
10 var getRandomValues: Function;
12 imports.wasi_snapshot_preview1 = {
13 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
14 // This should generally only be used to print panic messages
15 console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
16 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
17 for (var i = 0; i < iovec_array_len; i++) {
18 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
19 console.log(String.fromCharCode(...bytes_view));
23 "fd_close": (_fd: number) => {
24 // This is not generally called, but may be referenced in debug builds
25 console.log("wasi_snapshot_preview1:fd_close");
26 return 58; // Not Supported
28 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
29 // This is not generally called, but may be referenced in debug builds
30 console.log("wasi_snapshot_preview1:fd_seek");
31 return 58; // Not Supported
33 "random_get": (buf_ptr: number, buf_len: number) => {
34 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
38 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
39 // This is called before fd_write to format + print panic messages
40 console.log("wasi_snapshot_preview1:environ_sizes_get");
41 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
42 out_count_view[0] = 0;
43 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
47 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
48 // This is called before fd_write to format + print panic messages
49 console.log("wasi_snapshot_preview1:environ_get");
50 return 58; // Note supported - we said there were 0 environment entries!
53 console.log("wasi_snapshot_preview1:proc_exit");
58 let isWasmInitialized: boolean = false;
60 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
61 if (typeof crypto === "undefined") {
62 var crypto_import = (await import('crypto')).webcrypto;
63 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
65 getRandomValues = crypto.getRandomValues.bind(crypto);
68 wasm = wasmInstance.exports;
69 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
70 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
73 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
74 throw new Error("Compiled LDK library and LDK class files do not match");
75 // Fetching the LDK versions from C also checks that the header and binaries match
76 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
77 const ldk_ver: number = wasm.TS_get_ldk_version();
78 if (c_bindings_ver == 0)
79 throw new Error("LDK version did not match the header we built against");
81 throw new Error("LDK C bindings version did not match the header we built against");
82 const c_bindings_version: string = decodeString(c_bindings_ver)
83 const ldk_version: string = decodeString(ldk_ver);
84 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
86 isWasmInitialized = true;
90 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
91 imports.env["js_invoke_function_u"] = js_invoke;
92 imports.env["js_invoke_function_b"] = js_invoke;
93 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
94 await finishInitializeWasm(wasmInstance);
98 export async function initializeWasmFetch(uri: string) {
99 const stream = fetch(uri);
100 imports.env["js_invoke_function_u"] = js_invoke;
101 imports.env["js_invoke_function_b"] = js_invoke;
102 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
103 await finishInitializeWasm(wasmInstance);
108 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
109 const arr = new Uint8Array(inputArray.length);
110 for (var i = 0; i < inputArray.length; i++) {
111 arr[i] = inputArray[i].getVal();
117 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
118 const arr = new Uint8Array(inputArray.length);
119 for (var i = 0; i < inputArray.length; i++) {
120 arr[i] = inputArray[i].getVal();
128 export function encodeUint8Array (inputArray: Uint8Array): number {
129 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
130 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
131 arrayLengthView[0] = inputArray.length;
132 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
133 arrayMemoryView.set(inputArray);
134 return cArrayPointer;
137 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
138 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
139 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
140 arrayMemoryView.set(inputArray, 1);
141 arrayMemoryView[0] = inputArray.length;
142 return cArrayPointer;
145 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
146 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
147 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
148 arrayLengthView[0] = inputArray.length;
149 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
150 arrayMemoryView.set(inputArray);
151 return cArrayPointer;
155 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
156 if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
161 export function getArrayLength(arrayPointer: number): number {
162 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
163 return arraySizeViewer[0];
166 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
167 const arraySize = getArrayLength(arrayPointer);
168 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
169 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
170 // will free the underlying memory when it becomes unreachable instead of copying here.
171 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
172 const actualArray = actualArrayViewer.slice(0, arraySize);
174 wasm.TS_free(arrayPointer);
178 const decodeUint32Array = (arrayPointer: number, free = true) => {
179 const arraySize = getArrayLength(arrayPointer);
180 const actualArrayViewer = new Uint32Array(
181 wasm.memory.buffer, // value
182 arrayPointer + 4, // offset (ignoring length bytes)
183 arraySize // uint32 count
185 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
186 // will free the underlying memory when it becomes unreachable instead of copying here.
187 const actualArray = actualArrayViewer.slice(0, arraySize);
189 wasm.TS_free(arrayPointer);
195 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
198 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
199 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
200 return actualArrayViewer[idx];
204 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
205 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
206 return actualArrayViewer[idx];
211 export function encodeString(str: string): number {
212 const charArray = new TextEncoder().encode(str);
213 return encodeUint8Array(charArray);
217 export function decodeString(stringPointer: number, free = true): string {
218 const arraySize = getArrayLength(stringPointer);
219 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
220 const result = new TextDecoder("utf-8").decode(memoryView);
223 wasm.TS_free(stringPointer);
229 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
230 /* @internal */ export function debugPrintRemainingAllocs() { }
233 export enum AccessError {
235 * The requested chain is unknown.
237 LDKAccessError_UnknownChain,
239 * The requested transaction doesn't exist or hasn't confirmed.
241 LDKAccessError_UnknownTx,
246 export enum COption_NoneZ {
248 * When we're in this state, this COption_NoneZ contains a
250 LDKCOption_NoneZ_Some,
252 * When we're in this state, this COption_NoneZ contains nothing
254 LDKCOption_NoneZ_None,
259 export enum ChannelMonitorUpdateErr {
261 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
262 our state failed, but is expected to succeed at some point in the future).
264 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
265 submitting new commitment transactions to the counterparty. Once the update(s) that failed
266 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
267 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
270 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
271 you return a TemporaryFailure you must ensure that it is written to disk safely before
272 writing out the latest ChannelManager state.
274 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
275 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
276 to claim it on this channel) and those updates must be applied wherever they can be. At
277 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
278 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
279 the channel which would invalidate previous ChannelMonitors are not made when a channel has
282 Note that even if updates made after TemporaryFailure succeed you must still provide a
283 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
284 normal channel operation. Note that this is normally generated through a call to
285 [`ChainMonitor::channel_monitor_updated`].
287 Note that the update being processed here will not be replayed for you when you return a
288 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
289 you must store the update itself on your own local disk prior to returning a
290 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
291 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
294 For deployments where a copy of ChannelMonitors and other local state are backed up in a
295 remote location (with local copies persisted immediately), it is anticipated that all
296 updates will return TemporaryFailure until the remote copies could be updated.
298 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
300 LDKChannelMonitorUpdateErr_TemporaryFailure,
302 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
303 different watchtower and cannot update with all watchtowers that were previously informed
306 At reception of this error, ChannelManager will force-close the channel and return at
307 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
308 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
309 update must be rejected.
311 This failure may also signal a failure to update the local persisted copy of one of
312 the channel monitor instance.
314 Note that even when you fail a holder commitment transaction update, you must store the
315 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
316 broadcasts it (e.g distributed channel-monitor deployment)
318 In case of distributed watchtowers deployment, the new version must be written to disk, as
319 state may have been stored but rejected due to a block forcing a commitment broadcast. This
320 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
321 lagging behind on block processing.
323 LDKChannelMonitorUpdateErr_PermanentFailure,
328 export enum ConfirmationTarget {
330 * We are happy with this transaction confirming slowly when feerate drops some.
332 LDKConfirmationTarget_Background,
334 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
336 LDKConfirmationTarget_Normal,
338 * We'd like this transaction to confirm in the next few blocks.
340 LDKConfirmationTarget_HighPriority,
345 export enum CreationError {
347 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
349 LDKCreationError_DescriptionTooLong,
351 * The specified route has too many hops and can't be encoded
353 LDKCreationError_RouteTooLong,
355 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
357 LDKCreationError_TimestampOutOfBounds,
359 * The supplied millisatoshi amount was greater than the total bitcoin supply.
361 LDKCreationError_InvalidAmount,
363 * Route hints were required for this invoice and were missing. Applies to
366 [phantom invoices]: crate::utils::create_phantom_invoice
368 LDKCreationError_MissingRouteHints,
373 export enum Currency {
381 LDKCurrency_BitcoinTestnet,
398 export enum IOError {
400 LDKIOError_PermissionDenied,
401 LDKIOError_ConnectionRefused,
402 LDKIOError_ConnectionReset,
403 LDKIOError_ConnectionAborted,
404 LDKIOError_NotConnected,
405 LDKIOError_AddrInUse,
406 LDKIOError_AddrNotAvailable,
407 LDKIOError_BrokenPipe,
408 LDKIOError_AlreadyExists,
409 LDKIOError_WouldBlock,
410 LDKIOError_InvalidInput,
411 LDKIOError_InvalidData,
413 LDKIOError_WriteZero,
414 LDKIOError_Interrupted,
416 LDKIOError_UnexpectedEof,
423 * Designates extremely verbose information, including gossip-induced messages
427 * Designates very low priority, often extremely verbose, information
431 * Designates lower priority information
435 * Designates useful information
439 * Designates hazardous situations
443 * Designates very serious errors
450 export enum Network {
452 * The main Bitcoin blockchain.
456 * The testnet3 blockchain.
460 * A local test blockchain.
464 * A blockchain on which blocks are signed instead of mined.
471 export enum Recipient {
473 * The invoice should be signed with the local node secret key.
477 * The invoice should be signed with the phantom node secret key. This secret key must be the
478 same for all nodes participating in the [phantom node payment].
480 [phantom node payment]: PhantomKeysManager
482 LDKRecipient_PhantomNode,
487 export enum Secp256k1Error {
489 * Signature failed verification
491 LDKSecp256k1Error_IncorrectSignature,
493 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
495 LDKSecp256k1Error_InvalidMessage,
499 LDKSecp256k1Error_InvalidPublicKey,
503 LDKSecp256k1Error_InvalidSignature,
507 LDKSecp256k1Error_InvalidSecretKey,
511 LDKSecp256k1Error_InvalidSharedSecret,
515 LDKSecp256k1Error_InvalidRecoveryId,
517 * Invalid tweak for add_assign or mul_assign
519 LDKSecp256k1Error_InvalidTweak,
521 * Didn't pass enough memory to context creation with preallocated memory
523 LDKSecp256k1Error_NotEnoughMemory,
525 * Bad set of public keys.
527 LDKSecp256k1Error_InvalidPublicKeySum,
529 * The only valid parity values are 0 or 1.
531 LDKSecp256k1Error_InvalidParityValue,
536 export enum SemanticError {
538 * The invoice is missing the mandatory payment hash
540 LDKSemanticError_NoPaymentHash,
542 * The invoice has multiple payment hashes which isn't allowed
544 LDKSemanticError_MultiplePaymentHashes,
546 * No description or description hash are part of the invoice
548 LDKSemanticError_NoDescription,
550 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
552 LDKSemanticError_MultipleDescriptions,
554 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
557 LDKSemanticError_NoPaymentSecret,
559 * The invoice contains multiple payment secrets
561 LDKSemanticError_MultiplePaymentSecrets,
563 * The invoice's features are invalid
565 LDKSemanticError_InvalidFeatures,
567 * The recovery id doesn't fit the signature/pub key
569 LDKSemanticError_InvalidRecoveryId,
571 * The invoice's signature is invalid
573 LDKSemanticError_InvalidSignature,
575 * The invoice's amount was not a whole number of millisatoshis
577 LDKSemanticError_ImpreciseAmount,
582 export enum SiPrefix {
602 export class LDKBech32Error {
603 protected constructor() {}
606 export function LDKBech32Error_ty_from_ptr(ptr: number): number {
607 if(!isWasmInitialized) {
608 throw new Error("initializeWasm() must be awaited first!");
610 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
611 return nativeResponseValue;
614 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: number): number {
615 if(!isWasmInitialized) {
616 throw new Error("initializeWasm() must be awaited first!");
618 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
619 return nativeResponseValue;
622 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: number): number {
623 if(!isWasmInitialized) {
624 throw new Error("initializeWasm() must be awaited first!");
626 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
627 return nativeResponseValue;
629 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
631 export function TxOut_get_script_pubkey(thing: number): number {
632 if(!isWasmInitialized) {
633 throw new Error("initializeWasm() must be awaited first!");
635 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
636 return nativeResponseValue;
638 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
640 export function TxOut_get_value(thing: number): bigint {
641 if(!isWasmInitialized) {
642 throw new Error("initializeWasm() must be awaited first!");
644 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
645 return nativeResponseValue;
647 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
649 export function CResult_NoneNoneZ_get_ok(owner: number): void {
650 if(!isWasmInitialized) {
651 throw new Error("initializeWasm() must be awaited first!");
653 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
654 // debug statements here
656 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
658 export function CResult_NoneNoneZ_get_err(owner: number): void {
659 if(!isWasmInitialized) {
660 throw new Error("initializeWasm() must be awaited first!");
662 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
663 // debug statements here
665 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
667 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
668 if(!isWasmInitialized) {
669 throw new Error("initializeWasm() must be awaited first!");
671 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
672 return nativeResponseValue;
674 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
676 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
677 if(!isWasmInitialized) {
678 throw new Error("initializeWasm() must be awaited first!");
680 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
681 return nativeResponseValue;
683 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
685 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
686 if(!isWasmInitialized) {
687 throw new Error("initializeWasm() must be awaited first!");
689 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
690 return nativeResponseValue;
692 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
694 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
695 if(!isWasmInitialized) {
696 throw new Error("initializeWasm() must be awaited first!");
698 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
699 return nativeResponseValue;
701 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
703 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
704 if(!isWasmInitialized) {
705 throw new Error("initializeWasm() must be awaited first!");
707 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
708 return nativeResponseValue;
710 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
712 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
713 if(!isWasmInitialized) {
714 throw new Error("initializeWasm() must be awaited first!");
716 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
717 return nativeResponseValue;
719 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
721 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
722 if(!isWasmInitialized) {
723 throw new Error("initializeWasm() must be awaited first!");
725 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
726 return nativeResponseValue;
728 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
730 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
731 if(!isWasmInitialized) {
732 throw new Error("initializeWasm() must be awaited first!");
734 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
735 return nativeResponseValue;
737 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
739 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
740 if(!isWasmInitialized) {
741 throw new Error("initializeWasm() must be awaited first!");
743 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
744 return nativeResponseValue;
746 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
748 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
749 if(!isWasmInitialized) {
750 throw new Error("initializeWasm() must be awaited first!");
752 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
753 return nativeResponseValue;
755 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
757 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
758 if(!isWasmInitialized) {
759 throw new Error("initializeWasm() must be awaited first!");
761 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
762 return nativeResponseValue;
764 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
766 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
767 if(!isWasmInitialized) {
768 throw new Error("initializeWasm() must be awaited first!");
770 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
771 return nativeResponseValue;
774 export class LDKCOption_u32Z {
775 protected constructor() {}
778 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
783 return nativeResponseValue;
786 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
787 if(!isWasmInitialized) {
788 throw new Error("initializeWasm() must be awaited first!");
790 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
791 return nativeResponseValue;
793 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
795 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
796 if(!isWasmInitialized) {
797 throw new Error("initializeWasm() must be awaited first!");
799 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
800 return nativeResponseValue;
802 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
804 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
805 if(!isWasmInitialized) {
806 throw new Error("initializeWasm() must be awaited first!");
808 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
809 return nativeResponseValue;
811 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
813 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
814 if(!isWasmInitialized) {
815 throw new Error("initializeWasm() must be awaited first!");
817 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
818 return nativeResponseValue;
820 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
822 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
823 if(!isWasmInitialized) {
824 throw new Error("initializeWasm() must be awaited first!");
826 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
827 return nativeResponseValue;
829 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
831 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
832 if(!isWasmInitialized) {
833 throw new Error("initializeWasm() must be awaited first!");
835 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
836 return nativeResponseValue;
838 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
840 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
841 if(!isWasmInitialized) {
842 throw new Error("initializeWasm() must be awaited first!");
844 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
845 return nativeResponseValue;
847 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
849 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
850 if(!isWasmInitialized) {
851 throw new Error("initializeWasm() must be awaited first!");
853 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
854 return nativeResponseValue;
856 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
858 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
859 if(!isWasmInitialized) {
860 throw new Error("initializeWasm() must be awaited first!");
862 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
863 return nativeResponseValue;
865 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
867 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
868 if(!isWasmInitialized) {
869 throw new Error("initializeWasm() must be awaited first!");
871 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
872 return nativeResponseValue;
874 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
876 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
877 if(!isWasmInitialized) {
878 throw new Error("initializeWasm() must be awaited first!");
880 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
881 return nativeResponseValue;
883 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
885 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
886 if(!isWasmInitialized) {
887 throw new Error("initializeWasm() must be awaited first!");
889 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
890 return nativeResponseValue;
892 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
894 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
895 if(!isWasmInitialized) {
896 throw new Error("initializeWasm() must be awaited first!");
898 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
899 // debug statements here
901 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
903 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
904 if(!isWasmInitialized) {
905 throw new Error("initializeWasm() must be awaited first!");
907 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
908 return nativeResponseValue;
910 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
912 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
913 if(!isWasmInitialized) {
914 throw new Error("initializeWasm() must be awaited first!");
916 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
917 return nativeResponseValue;
919 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
921 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
922 if(!isWasmInitialized) {
923 throw new Error("initializeWasm() must be awaited first!");
925 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
926 return nativeResponseValue;
928 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
930 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
931 if(!isWasmInitialized) {
932 throw new Error("initializeWasm() must be awaited first!");
934 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
935 // debug statements here
937 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
939 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
940 if(!isWasmInitialized) {
941 throw new Error("initializeWasm() must be awaited first!");
943 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
944 return nativeResponseValue;
946 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
948 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
949 if(!isWasmInitialized) {
950 throw new Error("initializeWasm() must be awaited first!");
952 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
953 // debug statements here
955 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
957 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
958 if(!isWasmInitialized) {
959 throw new Error("initializeWasm() must be awaited first!");
961 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
962 return nativeResponseValue;
964 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
966 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
967 if(!isWasmInitialized) {
968 throw new Error("initializeWasm() must be awaited first!");
970 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
971 return nativeResponseValue;
973 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
975 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
976 if(!isWasmInitialized) {
977 throw new Error("initializeWasm() must be awaited first!");
979 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
980 return nativeResponseValue;
982 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
984 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
985 if(!isWasmInitialized) {
986 throw new Error("initializeWasm() must be awaited first!");
988 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
989 return nativeResponseValue;
991 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
993 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
994 if(!isWasmInitialized) {
995 throw new Error("initializeWasm() must be awaited first!");
997 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
998 return nativeResponseValue;
1000 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1002 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1003 if(!isWasmInitialized) {
1004 throw new Error("initializeWasm() must be awaited first!");
1006 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1007 return nativeResponseValue;
1009 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1011 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1012 if(!isWasmInitialized) {
1013 throw new Error("initializeWasm() must be awaited first!");
1015 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1016 return nativeResponseValue;
1018 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1020 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1021 if(!isWasmInitialized) {
1022 throw new Error("initializeWasm() must be awaited first!");
1024 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1025 return nativeResponseValue;
1027 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1029 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1030 if(!isWasmInitialized) {
1031 throw new Error("initializeWasm() must be awaited first!");
1033 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1034 return nativeResponseValue;
1036 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1038 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1039 if(!isWasmInitialized) {
1040 throw new Error("initializeWasm() must be awaited first!");
1042 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1043 return nativeResponseValue;
1046 export class LDKCOption_u64Z {
1047 protected constructor() {}
1050 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1051 if(!isWasmInitialized) {
1052 throw new Error("initializeWasm() must be awaited first!");
1054 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1055 return nativeResponseValue;
1058 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1059 if(!isWasmInitialized) {
1060 throw new Error("initializeWasm() must be awaited first!");
1062 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1063 return nativeResponseValue;
1065 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1067 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
1068 if(!isWasmInitialized) {
1069 throw new Error("initializeWasm() must be awaited first!");
1071 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1072 return nativeResponseValue;
1074 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1076 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1077 if(!isWasmInitialized) {
1078 throw new Error("initializeWasm() must be awaited first!");
1080 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1081 return nativeResponseValue;
1083 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1085 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1086 if(!isWasmInitialized) {
1087 throw new Error("initializeWasm() must be awaited first!");
1089 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1090 return nativeResponseValue;
1092 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1094 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1095 if(!isWasmInitialized) {
1096 throw new Error("initializeWasm() must be awaited first!");
1098 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1099 return nativeResponseValue;
1101 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1103 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1104 if(!isWasmInitialized) {
1105 throw new Error("initializeWasm() must be awaited first!");
1107 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1108 return nativeResponseValue;
1110 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1112 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1113 if(!isWasmInitialized) {
1114 throw new Error("initializeWasm() must be awaited first!");
1116 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1117 return nativeResponseValue;
1119 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1121 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1122 if(!isWasmInitialized) {
1123 throw new Error("initializeWasm() must be awaited first!");
1125 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1126 return nativeResponseValue;
1128 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1130 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1131 if(!isWasmInitialized) {
1132 throw new Error("initializeWasm() must be awaited first!");
1134 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1135 return nativeResponseValue;
1138 export class LDKPaymentPurpose {
1139 protected constructor() {}
1142 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1143 if(!isWasmInitialized) {
1144 throw new Error("initializeWasm() must be awaited first!");
1146 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1147 return nativeResponseValue;
1150 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1151 if(!isWasmInitialized) {
1152 throw new Error("initializeWasm() must be awaited first!");
1154 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1155 return nativeResponseValue;
1158 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1159 if(!isWasmInitialized) {
1160 throw new Error("initializeWasm() must be awaited first!");
1162 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1163 return nativeResponseValue;
1166 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1167 if(!isWasmInitialized) {
1168 throw new Error("initializeWasm() must be awaited first!");
1170 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1171 return nativeResponseValue;
1173 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1175 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: number): number {
1176 if(!isWasmInitialized) {
1177 throw new Error("initializeWasm() must be awaited first!");
1179 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1180 return nativeResponseValue;
1182 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1184 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: number): number {
1185 if(!isWasmInitialized) {
1186 throw new Error("initializeWasm() must be awaited first!");
1188 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1189 return nativeResponseValue;
1192 export class LDKClosureReason {
1193 protected constructor() {}
1196 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1197 if(!isWasmInitialized) {
1198 throw new Error("initializeWasm() must be awaited first!");
1200 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1201 return nativeResponseValue;
1204 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1205 if(!isWasmInitialized) {
1206 throw new Error("initializeWasm() must be awaited first!");
1208 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1209 return nativeResponseValue;
1212 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1213 if(!isWasmInitialized) {
1214 throw new Error("initializeWasm() must be awaited first!");
1216 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1217 return nativeResponseValue;
1220 export class LDKCOption_ClosureReasonZ {
1221 protected constructor() {}
1224 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1225 if(!isWasmInitialized) {
1226 throw new Error("initializeWasm() must be awaited first!");
1228 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1229 return nativeResponseValue;
1232 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1237 return nativeResponseValue;
1239 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1241 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1242 if(!isWasmInitialized) {
1243 throw new Error("initializeWasm() must be awaited first!");
1245 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1246 return nativeResponseValue;
1248 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1250 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1251 if(!isWasmInitialized) {
1252 throw new Error("initializeWasm() must be awaited first!");
1254 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1255 return nativeResponseValue;
1258 export class LDKNetworkUpdate {
1259 protected constructor() {}
1262 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1263 if(!isWasmInitialized) {
1264 throw new Error("initializeWasm() must be awaited first!");
1266 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1267 return nativeResponseValue;
1270 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1271 if(!isWasmInitialized) {
1272 throw new Error("initializeWasm() must be awaited first!");
1274 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1275 return nativeResponseValue;
1278 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: number): bigint {
1279 if(!isWasmInitialized) {
1280 throw new Error("initializeWasm() must be awaited first!");
1282 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1283 return nativeResponseValue;
1286 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: number): boolean {
1287 if(!isWasmInitialized) {
1288 throw new Error("initializeWasm() must be awaited first!");
1290 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1291 return nativeResponseValue;
1294 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1295 if(!isWasmInitialized) {
1296 throw new Error("initializeWasm() must be awaited first!");
1298 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1299 return nativeResponseValue;
1302 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1303 if(!isWasmInitialized) {
1304 throw new Error("initializeWasm() must be awaited first!");
1306 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1307 return nativeResponseValue;
1310 export class LDKCOption_NetworkUpdateZ {
1311 protected constructor() {}
1314 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1315 if(!isWasmInitialized) {
1316 throw new Error("initializeWasm() must be awaited first!");
1318 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1319 return nativeResponseValue;
1322 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1323 if(!isWasmInitialized) {
1324 throw new Error("initializeWasm() must be awaited first!");
1326 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1327 return nativeResponseValue;
1330 export class LDKSpendableOutputDescriptor {
1331 protected constructor() {}
1334 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1335 if(!isWasmInitialized) {
1336 throw new Error("initializeWasm() must be awaited first!");
1338 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1339 return nativeResponseValue;
1342 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1343 if(!isWasmInitialized) {
1344 throw new Error("initializeWasm() must be awaited first!");
1346 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1347 return nativeResponseValue;
1350 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1351 if(!isWasmInitialized) {
1352 throw new Error("initializeWasm() must be awaited first!");
1354 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1355 return nativeResponseValue;
1358 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1359 if(!isWasmInitialized) {
1360 throw new Error("initializeWasm() must be awaited first!");
1362 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1363 return nativeResponseValue;
1366 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1367 if(!isWasmInitialized) {
1368 throw new Error("initializeWasm() must be awaited first!");
1370 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1371 return nativeResponseValue;
1374 export class LDKEvent {
1375 protected constructor() {}
1378 export function LDKEvent_ty_from_ptr(ptr: number): number {
1379 if(!isWasmInitialized) {
1380 throw new Error("initializeWasm() must be awaited first!");
1382 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1383 return nativeResponseValue;
1386 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1387 if(!isWasmInitialized) {
1388 throw new Error("initializeWasm() must be awaited first!");
1390 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1391 return nativeResponseValue;
1394 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: number): number {
1395 if(!isWasmInitialized) {
1396 throw new Error("initializeWasm() must be awaited first!");
1398 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1399 return nativeResponseValue;
1402 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1403 if(!isWasmInitialized) {
1404 throw new Error("initializeWasm() must be awaited first!");
1406 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1407 return nativeResponseValue;
1410 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1411 if(!isWasmInitialized) {
1412 throw new Error("initializeWasm() must be awaited first!");
1414 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1415 return nativeResponseValue;
1418 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1419 if(!isWasmInitialized) {
1420 throw new Error("initializeWasm() must be awaited first!");
1422 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1423 return nativeResponseValue;
1426 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1427 if(!isWasmInitialized) {
1428 throw new Error("initializeWasm() must be awaited first!");
1430 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1431 return nativeResponseValue;
1434 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: number): bigint {
1435 if(!isWasmInitialized) {
1436 throw new Error("initializeWasm() must be awaited first!");
1438 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1439 return nativeResponseValue;
1442 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1443 if(!isWasmInitialized) {
1444 throw new Error("initializeWasm() must be awaited first!");
1446 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1447 return nativeResponseValue;
1450 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: number): number {
1451 if(!isWasmInitialized) {
1452 throw new Error("initializeWasm() must be awaited first!");
1454 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1455 return nativeResponseValue;
1458 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: number): bigint {
1459 if(!isWasmInitialized) {
1460 throw new Error("initializeWasm() must be awaited first!");
1462 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1463 return nativeResponseValue;
1466 export function LDKEvent_PaymentClaimed_get_purpose(ptr: number): number {
1467 if(!isWasmInitialized) {
1468 throw new Error("initializeWasm() must be awaited first!");
1470 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1471 return nativeResponseValue;
1474 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1475 if(!isWasmInitialized) {
1476 throw new Error("initializeWasm() must be awaited first!");
1478 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1479 return nativeResponseValue;
1482 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1483 if(!isWasmInitialized) {
1484 throw new Error("initializeWasm() must be awaited first!");
1486 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1487 return nativeResponseValue;
1490 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1495 return nativeResponseValue;
1498 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1499 if(!isWasmInitialized) {
1500 throw new Error("initializeWasm() must be awaited first!");
1502 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1503 return nativeResponseValue;
1506 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1507 if(!isWasmInitialized) {
1508 throw new Error("initializeWasm() must be awaited first!");
1510 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1511 return nativeResponseValue;
1514 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1515 if(!isWasmInitialized) {
1516 throw new Error("initializeWasm() must be awaited first!");
1518 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1519 return nativeResponseValue;
1522 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1523 if(!isWasmInitialized) {
1524 throw new Error("initializeWasm() must be awaited first!");
1526 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1527 return nativeResponseValue;
1530 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1531 if(!isWasmInitialized) {
1532 throw new Error("initializeWasm() must be awaited first!");
1534 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1535 return nativeResponseValue;
1538 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1539 if(!isWasmInitialized) {
1540 throw new Error("initializeWasm() must be awaited first!");
1542 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1543 return nativeResponseValue;
1546 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1547 if(!isWasmInitialized) {
1548 throw new Error("initializeWasm() must be awaited first!");
1550 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1551 return nativeResponseValue;
1554 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1555 if(!isWasmInitialized) {
1556 throw new Error("initializeWasm() must be awaited first!");
1558 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1559 return nativeResponseValue;
1562 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1563 if(!isWasmInitialized) {
1564 throw new Error("initializeWasm() must be awaited first!");
1566 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1567 return nativeResponseValue;
1570 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1571 if(!isWasmInitialized) {
1572 throw new Error("initializeWasm() must be awaited first!");
1574 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1575 return nativeResponseValue;
1578 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1579 if(!isWasmInitialized) {
1580 throw new Error("initializeWasm() must be awaited first!");
1582 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1583 return nativeResponseValue;
1586 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1587 if(!isWasmInitialized) {
1588 throw new Error("initializeWasm() must be awaited first!");
1590 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1591 return nativeResponseValue;
1594 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1595 if(!isWasmInitialized) {
1596 throw new Error("initializeWasm() must be awaited first!");
1598 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1599 return nativeResponseValue;
1602 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1603 if(!isWasmInitialized) {
1604 throw new Error("initializeWasm() must be awaited first!");
1606 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1607 return nativeResponseValue;
1610 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1611 if(!isWasmInitialized) {
1612 throw new Error("initializeWasm() must be awaited first!");
1614 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1615 return nativeResponseValue;
1618 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1619 if(!isWasmInitialized) {
1620 throw new Error("initializeWasm() must be awaited first!");
1622 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1623 return nativeResponseValue;
1626 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: number): number {
1627 if(!isWasmInitialized) {
1628 throw new Error("initializeWasm() must be awaited first!");
1630 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1631 return nativeResponseValue;
1634 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: number): number {
1635 if(!isWasmInitialized) {
1636 throw new Error("initializeWasm() must be awaited first!");
1638 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1639 return nativeResponseValue;
1642 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1643 if(!isWasmInitialized) {
1644 throw new Error("initializeWasm() must be awaited first!");
1646 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1647 return nativeResponseValue;
1650 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1651 if(!isWasmInitialized) {
1652 throw new Error("initializeWasm() must be awaited first!");
1654 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1655 return nativeResponseValue;
1658 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1659 if(!isWasmInitialized) {
1660 throw new Error("initializeWasm() must be awaited first!");
1662 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1663 return nativeResponseValue;
1666 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1667 if(!isWasmInitialized) {
1668 throw new Error("initializeWasm() must be awaited first!");
1670 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1671 return nativeResponseValue;
1674 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1675 if(!isWasmInitialized) {
1676 throw new Error("initializeWasm() must be awaited first!");
1678 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1679 return nativeResponseValue;
1682 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1683 if(!isWasmInitialized) {
1684 throw new Error("initializeWasm() must be awaited first!");
1686 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1687 return nativeResponseValue;
1690 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1691 if(!isWasmInitialized) {
1692 throw new Error("initializeWasm() must be awaited first!");
1694 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1695 return nativeResponseValue;
1698 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1699 if(!isWasmInitialized) {
1700 throw new Error("initializeWasm() must be awaited first!");
1702 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1703 return nativeResponseValue;
1706 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1707 if(!isWasmInitialized) {
1708 throw new Error("initializeWasm() must be awaited first!");
1710 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1711 return nativeResponseValue;
1714 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1715 if(!isWasmInitialized) {
1716 throw new Error("initializeWasm() must be awaited first!");
1718 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1719 return nativeResponseValue;
1722 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1723 if(!isWasmInitialized) {
1724 throw new Error("initializeWasm() must be awaited first!");
1726 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1727 return nativeResponseValue;
1730 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1731 if(!isWasmInitialized) {
1732 throw new Error("initializeWasm() must be awaited first!");
1734 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1735 return nativeResponseValue;
1738 export class LDKCOption_EventZ {
1739 protected constructor() {}
1742 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1743 if(!isWasmInitialized) {
1744 throw new Error("initializeWasm() must be awaited first!");
1746 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1747 return nativeResponseValue;
1750 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1751 if(!isWasmInitialized) {
1752 throw new Error("initializeWasm() must be awaited first!");
1754 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1755 return nativeResponseValue;
1757 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1759 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1760 if(!isWasmInitialized) {
1761 throw new Error("initializeWasm() must be awaited first!");
1763 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1764 return nativeResponseValue;
1766 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1768 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1769 if(!isWasmInitialized) {
1770 throw new Error("initializeWasm() must be awaited first!");
1772 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1773 return nativeResponseValue;
1776 export class LDKErrorAction {
1777 protected constructor() {}
1780 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1781 if(!isWasmInitialized) {
1782 throw new Error("initializeWasm() must be awaited first!");
1784 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1785 return nativeResponseValue;
1788 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1789 if(!isWasmInitialized) {
1790 throw new Error("initializeWasm() must be awaited first!");
1792 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1793 return nativeResponseValue;
1796 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1797 if(!isWasmInitialized) {
1798 throw new Error("initializeWasm() must be awaited first!");
1800 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1801 return nativeResponseValue;
1804 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1805 if(!isWasmInitialized) {
1806 throw new Error("initializeWasm() must be awaited first!");
1808 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1809 return nativeResponseValue;
1812 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1813 if(!isWasmInitialized) {
1814 throw new Error("initializeWasm() must be awaited first!");
1816 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
1817 return nativeResponseValue;
1820 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
1821 if(!isWasmInitialized) {
1822 throw new Error("initializeWasm() must be awaited first!");
1824 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
1825 return nativeResponseValue;
1828 export class LDKMessageSendEvent {
1829 protected constructor() {}
1832 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
1833 if(!isWasmInitialized) {
1834 throw new Error("initializeWasm() must be awaited first!");
1836 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
1837 return nativeResponseValue;
1840 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
1841 if(!isWasmInitialized) {
1842 throw new Error("initializeWasm() must be awaited first!");
1844 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
1845 return nativeResponseValue;
1848 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
1849 if(!isWasmInitialized) {
1850 throw new Error("initializeWasm() must be awaited first!");
1852 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
1853 return nativeResponseValue;
1856 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
1857 if(!isWasmInitialized) {
1858 throw new Error("initializeWasm() must be awaited first!");
1860 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
1861 return nativeResponseValue;
1864 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
1865 if(!isWasmInitialized) {
1866 throw new Error("initializeWasm() must be awaited first!");
1868 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
1869 return nativeResponseValue;
1872 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
1873 if(!isWasmInitialized) {
1874 throw new Error("initializeWasm() must be awaited first!");
1876 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
1877 return nativeResponseValue;
1880 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
1881 if(!isWasmInitialized) {
1882 throw new Error("initializeWasm() must be awaited first!");
1884 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
1885 return nativeResponseValue;
1888 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
1889 if(!isWasmInitialized) {
1890 throw new Error("initializeWasm() must be awaited first!");
1892 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
1893 return nativeResponseValue;
1896 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
1897 if(!isWasmInitialized) {
1898 throw new Error("initializeWasm() must be awaited first!");
1900 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
1901 return nativeResponseValue;
1904 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: number): number {
1905 if(!isWasmInitialized) {
1906 throw new Error("initializeWasm() must be awaited first!");
1908 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
1909 return nativeResponseValue;
1912 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: number): number {
1913 if(!isWasmInitialized) {
1914 throw new Error("initializeWasm() must be awaited first!");
1916 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
1917 return nativeResponseValue;
1920 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
1921 if(!isWasmInitialized) {
1922 throw new Error("initializeWasm() must be awaited first!");
1924 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
1925 return nativeResponseValue;
1928 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
1929 if(!isWasmInitialized) {
1930 throw new Error("initializeWasm() must be awaited first!");
1932 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
1933 return nativeResponseValue;
1936 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
1937 if(!isWasmInitialized) {
1938 throw new Error("initializeWasm() must be awaited first!");
1940 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
1941 return nativeResponseValue;
1944 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
1945 if(!isWasmInitialized) {
1946 throw new Error("initializeWasm() must be awaited first!");
1948 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
1949 return nativeResponseValue;
1952 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
1953 if(!isWasmInitialized) {
1954 throw new Error("initializeWasm() must be awaited first!");
1956 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
1957 return nativeResponseValue;
1960 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
1961 if(!isWasmInitialized) {
1962 throw new Error("initializeWasm() must be awaited first!");
1964 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
1965 return nativeResponseValue;
1968 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
1973 return nativeResponseValue;
1976 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
1977 if(!isWasmInitialized) {
1978 throw new Error("initializeWasm() must be awaited first!");
1980 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
1981 return nativeResponseValue;
1984 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
1985 if(!isWasmInitialized) {
1986 throw new Error("initializeWasm() must be awaited first!");
1988 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
1989 return nativeResponseValue;
1992 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
1993 if(!isWasmInitialized) {
1994 throw new Error("initializeWasm() must be awaited first!");
1996 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
1997 return nativeResponseValue;
2000 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2001 if(!isWasmInitialized) {
2002 throw new Error("initializeWasm() must be awaited first!");
2004 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2005 return nativeResponseValue;
2008 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2009 if(!isWasmInitialized) {
2010 throw new Error("initializeWasm() must be awaited first!");
2012 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2013 return nativeResponseValue;
2016 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2017 if(!isWasmInitialized) {
2018 throw new Error("initializeWasm() must be awaited first!");
2020 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2021 return nativeResponseValue;
2024 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2025 if(!isWasmInitialized) {
2026 throw new Error("initializeWasm() must be awaited first!");
2028 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2029 return nativeResponseValue;
2032 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2033 if(!isWasmInitialized) {
2034 throw new Error("initializeWasm() must be awaited first!");
2036 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2037 return nativeResponseValue;
2040 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2041 if(!isWasmInitialized) {
2042 throw new Error("initializeWasm() must be awaited first!");
2044 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2045 return nativeResponseValue;
2048 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2049 if(!isWasmInitialized) {
2050 throw new Error("initializeWasm() must be awaited first!");
2052 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2053 return nativeResponseValue;
2056 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2057 if(!isWasmInitialized) {
2058 throw new Error("initializeWasm() must be awaited first!");
2060 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2061 return nativeResponseValue;
2064 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2065 if(!isWasmInitialized) {
2066 throw new Error("initializeWasm() must be awaited first!");
2068 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2069 return nativeResponseValue;
2072 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2073 if(!isWasmInitialized) {
2074 throw new Error("initializeWasm() must be awaited first!");
2076 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2077 return nativeResponseValue;
2080 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2081 if(!isWasmInitialized) {
2082 throw new Error("initializeWasm() must be awaited first!");
2084 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2085 return nativeResponseValue;
2088 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2089 if(!isWasmInitialized) {
2090 throw new Error("initializeWasm() must be awaited first!");
2092 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2093 return nativeResponseValue;
2096 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2097 if(!isWasmInitialized) {
2098 throw new Error("initializeWasm() must be awaited first!");
2100 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2101 return nativeResponseValue;
2104 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2105 if(!isWasmInitialized) {
2106 throw new Error("initializeWasm() must be awaited first!");
2108 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2109 return nativeResponseValue;
2112 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2113 if(!isWasmInitialized) {
2114 throw new Error("initializeWasm() must be awaited first!");
2116 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2117 return nativeResponseValue;
2120 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2121 if(!isWasmInitialized) {
2122 throw new Error("initializeWasm() must be awaited first!");
2124 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2125 return nativeResponseValue;
2128 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2129 if(!isWasmInitialized) {
2130 throw new Error("initializeWasm() must be awaited first!");
2132 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2133 return nativeResponseValue;
2136 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2137 if(!isWasmInitialized) {
2138 throw new Error("initializeWasm() must be awaited first!");
2140 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2141 return nativeResponseValue;
2143 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2145 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2146 if(!isWasmInitialized) {
2147 throw new Error("initializeWasm() must be awaited first!");
2149 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2150 return nativeResponseValue;
2152 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2154 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2155 if(!isWasmInitialized) {
2156 throw new Error("initializeWasm() must be awaited first!");
2158 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2159 return nativeResponseValue;
2161 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2163 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
2164 if(!isWasmInitialized) {
2165 throw new Error("initializeWasm() must be awaited first!");
2167 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2168 return nativeResponseValue;
2170 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2172 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
2173 if(!isWasmInitialized) {
2174 throw new Error("initializeWasm() must be awaited first!");
2176 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2177 return nativeResponseValue;
2179 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2181 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2182 if(!isWasmInitialized) {
2183 throw new Error("initializeWasm() must be awaited first!");
2185 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2186 // debug statements here
2188 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2190 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2191 if(!isWasmInitialized) {
2192 throw new Error("initializeWasm() must be awaited first!");
2194 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2195 return nativeResponseValue;
2198 export class LDKMonitorEvent {
2199 protected constructor() {}
2202 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
2203 if(!isWasmInitialized) {
2204 throw new Error("initializeWasm() must be awaited first!");
2206 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2207 return nativeResponseValue;
2210 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
2211 if(!isWasmInitialized) {
2212 throw new Error("initializeWasm() must be awaited first!");
2214 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2215 return nativeResponseValue;
2218 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
2219 if(!isWasmInitialized) {
2220 throw new Error("initializeWasm() must be awaited first!");
2222 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2223 return nativeResponseValue;
2226 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
2227 if(!isWasmInitialized) {
2228 throw new Error("initializeWasm() must be awaited first!");
2230 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2231 return nativeResponseValue;
2234 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
2235 if(!isWasmInitialized) {
2236 throw new Error("initializeWasm() must be awaited first!");
2238 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2239 return nativeResponseValue;
2242 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
2243 if(!isWasmInitialized) {
2244 throw new Error("initializeWasm() must be awaited first!");
2246 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2247 return nativeResponseValue;
2249 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorEventZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2251 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner: number): number {
2252 if(!isWasmInitialized) {
2253 throw new Error("initializeWasm() must be awaited first!");
2255 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner);
2256 return nativeResponseValue;
2258 // struct LDKCVec_MonitorEventZ C2Tuple_OutPointCVec_MonitorEventZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2260 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner: number): number {
2261 if(!isWasmInitialized) {
2262 throw new Error("initializeWasm() must be awaited first!");
2264 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner);
2265 return nativeResponseValue;
2268 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2269 protected constructor() {}
2272 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2273 if(!isWasmInitialized) {
2274 throw new Error("initializeWasm() must be awaited first!");
2276 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2277 return nativeResponseValue;
2280 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2281 if(!isWasmInitialized) {
2282 throw new Error("initializeWasm() must be awaited first!");
2284 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2285 return nativeResponseValue;
2287 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2289 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2294 return nativeResponseValue;
2296 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2298 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2299 if(!isWasmInitialized) {
2300 throw new Error("initializeWasm() must be awaited first!");
2302 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2303 return nativeResponseValue;
2306 export interface LDKLogger {
2307 log (record: number): void;
2311 export function LDKLogger_new(impl: LDKLogger): number {
2312 if(!isWasmInitialized) {
2313 throw new Error("initializeWasm() must be awaited first!");
2315 var new_obj_idx = js_objs.length;
2316 for (var i = 0; i < js_objs.length; i++) {
2317 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2319 js_objs[i] = new WeakRef(impl);
2320 return wasm.TS_LDKLogger_new(i);
2322 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2324 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2325 if(!isWasmInitialized) {
2326 throw new Error("initializeWasm() must be awaited first!");
2328 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2329 return nativeResponseValue;
2331 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2333 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2334 if(!isWasmInitialized) {
2335 throw new Error("initializeWasm() must be awaited first!");
2337 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2338 return nativeResponseValue;
2340 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2342 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2343 if(!isWasmInitialized) {
2344 throw new Error("initializeWasm() must be awaited first!");
2346 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2347 return nativeResponseValue;
2349 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2351 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2352 if(!isWasmInitialized) {
2353 throw new Error("initializeWasm() must be awaited first!");
2355 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2356 return nativeResponseValue;
2358 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2360 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2361 if(!isWasmInitialized) {
2362 throw new Error("initializeWasm() must be awaited first!");
2364 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2365 return nativeResponseValue;
2367 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2369 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2370 if(!isWasmInitialized) {
2371 throw new Error("initializeWasm() must be awaited first!");
2373 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2374 return nativeResponseValue;
2376 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2378 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2379 if(!isWasmInitialized) {
2380 throw new Error("initializeWasm() must be awaited first!");
2382 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2383 return nativeResponseValue;
2385 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2387 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2388 if(!isWasmInitialized) {
2389 throw new Error("initializeWasm() must be awaited first!");
2391 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2392 return nativeResponseValue;
2394 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2396 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2397 if(!isWasmInitialized) {
2398 throw new Error("initializeWasm() must be awaited first!");
2400 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2401 return nativeResponseValue;
2403 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2405 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2406 if(!isWasmInitialized) {
2407 throw new Error("initializeWasm() must be awaited first!");
2409 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2410 return nativeResponseValue;
2412 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2414 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2415 if(!isWasmInitialized) {
2416 throw new Error("initializeWasm() must be awaited first!");
2418 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2419 return nativeResponseValue;
2421 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2423 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2424 if(!isWasmInitialized) {
2425 throw new Error("initializeWasm() must be awaited first!");
2427 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2428 return nativeResponseValue;
2430 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2432 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2433 if(!isWasmInitialized) {
2434 throw new Error("initializeWasm() must be awaited first!");
2436 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2437 return nativeResponseValue;
2439 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2441 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2442 if(!isWasmInitialized) {
2443 throw new Error("initializeWasm() must be awaited first!");
2445 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2446 return nativeResponseValue;
2448 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2450 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2451 if(!isWasmInitialized) {
2452 throw new Error("initializeWasm() must be awaited first!");
2454 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2455 return nativeResponseValue;
2457 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2459 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2460 if(!isWasmInitialized) {
2461 throw new Error("initializeWasm() must be awaited first!");
2463 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2464 return nativeResponseValue;
2467 export interface LDKAccess {
2468 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2472 export function LDKAccess_new(impl: LDKAccess): number {
2473 if(!isWasmInitialized) {
2474 throw new Error("initializeWasm() must be awaited first!");
2476 var new_obj_idx = js_objs.length;
2477 for (var i = 0; i < js_objs.length; i++) {
2478 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2480 js_objs[i] = new WeakRef(impl);
2481 return wasm.TS_LDKAccess_new(i);
2483 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2485 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2486 if(!isWasmInitialized) {
2487 throw new Error("initializeWasm() must be awaited first!");
2489 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2490 return nativeResponseValue;
2493 export class LDKCOption_AccessZ {
2494 protected constructor() {}
2497 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2498 if(!isWasmInitialized) {
2499 throw new Error("initializeWasm() must be awaited first!");
2501 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2502 return nativeResponseValue;
2505 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2506 if(!isWasmInitialized) {
2507 throw new Error("initializeWasm() must be awaited first!");
2509 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2510 return nativeResponseValue;
2512 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2514 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2515 if(!isWasmInitialized) {
2516 throw new Error("initializeWasm() must be awaited first!");
2518 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2519 return nativeResponseValue;
2521 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2523 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2524 if(!isWasmInitialized) {
2525 throw new Error("initializeWasm() must be awaited first!");
2527 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2528 return nativeResponseValue;
2530 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2532 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2533 if(!isWasmInitialized) {
2534 throw new Error("initializeWasm() must be awaited first!");
2536 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2537 return nativeResponseValue;
2539 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2541 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2542 if(!isWasmInitialized) {
2543 throw new Error("initializeWasm() must be awaited first!");
2545 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2546 return nativeResponseValue;
2548 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2550 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2551 if(!isWasmInitialized) {
2552 throw new Error("initializeWasm() must be awaited first!");
2554 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2555 return nativeResponseValue;
2557 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2559 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2560 if(!isWasmInitialized) {
2561 throw new Error("initializeWasm() must be awaited first!");
2563 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2564 // debug statements here
2566 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2568 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2569 if(!isWasmInitialized) {
2570 throw new Error("initializeWasm() must be awaited first!");
2572 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2573 return nativeResponseValue;
2575 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2577 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
2578 if(!isWasmInitialized) {
2579 throw new Error("initializeWasm() must be awaited first!");
2581 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2582 return nativeResponseValue;
2584 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2586 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
2587 if(!isWasmInitialized) {
2588 throw new Error("initializeWasm() must be awaited first!");
2590 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2591 return nativeResponseValue;
2593 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2595 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2596 if(!isWasmInitialized) {
2597 throw new Error("initializeWasm() must be awaited first!");
2599 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2600 return nativeResponseValue;
2602 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2604 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2605 if(!isWasmInitialized) {
2606 throw new Error("initializeWasm() must be awaited first!");
2608 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2609 return nativeResponseValue;
2611 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2613 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2614 if(!isWasmInitialized) {
2615 throw new Error("initializeWasm() must be awaited first!");
2617 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2618 return nativeResponseValue;
2620 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2622 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2623 if(!isWasmInitialized) {
2624 throw new Error("initializeWasm() must be awaited first!");
2626 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2627 return nativeResponseValue;
2630 export class LDKNetAddress {
2631 protected constructor() {}
2634 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2635 if(!isWasmInitialized) {
2636 throw new Error("initializeWasm() must be awaited first!");
2638 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2639 return nativeResponseValue;
2642 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2643 if(!isWasmInitialized) {
2644 throw new Error("initializeWasm() must be awaited first!");
2646 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2647 return nativeResponseValue;
2650 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2651 if(!isWasmInitialized) {
2652 throw new Error("initializeWasm() must be awaited first!");
2654 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2655 return nativeResponseValue;
2658 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2659 if(!isWasmInitialized) {
2660 throw new Error("initializeWasm() must be awaited first!");
2662 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2663 return nativeResponseValue;
2666 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2667 if(!isWasmInitialized) {
2668 throw new Error("initializeWasm() must be awaited first!");
2670 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2671 return nativeResponseValue;
2674 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2675 if(!isWasmInitialized) {
2676 throw new Error("initializeWasm() must be awaited first!");
2678 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2679 return nativeResponseValue;
2682 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2683 if(!isWasmInitialized) {
2684 throw new Error("initializeWasm() must be awaited first!");
2686 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2687 return nativeResponseValue;
2690 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2691 if(!isWasmInitialized) {
2692 throw new Error("initializeWasm() must be awaited first!");
2694 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2695 return nativeResponseValue;
2698 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2699 if(!isWasmInitialized) {
2700 throw new Error("initializeWasm() must be awaited first!");
2702 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2703 return nativeResponseValue;
2706 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2707 if(!isWasmInitialized) {
2708 throw new Error("initializeWasm() must be awaited first!");
2710 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2711 return nativeResponseValue;
2713 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2715 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2716 if(!isWasmInitialized) {
2717 throw new Error("initializeWasm() must be awaited first!");
2719 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2720 return nativeResponseValue;
2722 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2724 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2725 if(!isWasmInitialized) {
2726 throw new Error("initializeWasm() must be awaited first!");
2728 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2729 return nativeResponseValue;
2731 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2733 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2734 if(!isWasmInitialized) {
2735 throw new Error("initializeWasm() must be awaited first!");
2737 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
2738 return nativeResponseValue;
2740 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2742 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
2743 if(!isWasmInitialized) {
2744 throw new Error("initializeWasm() must be awaited first!");
2746 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
2747 return nativeResponseValue;
2749 // struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2751 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
2752 if(!isWasmInitialized) {
2753 throw new Error("initializeWasm() must be awaited first!");
2755 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
2756 return nativeResponseValue;
2758 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2760 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
2761 if(!isWasmInitialized) {
2762 throw new Error("initializeWasm() must be awaited first!");
2764 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
2765 return nativeResponseValue;
2768 export class LDKCOption_CVec_NetAddressZZ {
2769 protected constructor() {}
2772 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
2773 if(!isWasmInitialized) {
2774 throw new Error("initializeWasm() must be awaited first!");
2776 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
2777 return nativeResponseValue;
2780 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
2781 if(!isWasmInitialized) {
2782 throw new Error("initializeWasm() must be awaited first!");
2784 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
2785 return nativeResponseValue;
2787 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2789 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2790 if(!isWasmInitialized) {
2791 throw new Error("initializeWasm() must be awaited first!");
2793 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2794 return nativeResponseValue;
2796 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2798 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2799 if(!isWasmInitialized) {
2800 throw new Error("initializeWasm() must be awaited first!");
2802 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2803 return nativeResponseValue;
2805 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2807 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2808 if(!isWasmInitialized) {
2809 throw new Error("initializeWasm() must be awaited first!");
2811 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2812 return nativeResponseValue;
2814 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2816 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2817 if(!isWasmInitialized) {
2818 throw new Error("initializeWasm() must be awaited first!");
2820 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2821 return nativeResponseValue;
2823 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2825 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2826 if(!isWasmInitialized) {
2827 throw new Error("initializeWasm() must be awaited first!");
2829 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2830 return nativeResponseValue;
2832 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2834 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2835 if(!isWasmInitialized) {
2836 throw new Error("initializeWasm() must be awaited first!");
2838 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2839 return nativeResponseValue;
2841 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2843 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2844 if(!isWasmInitialized) {
2845 throw new Error("initializeWasm() must be awaited first!");
2847 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2848 return nativeResponseValue;
2850 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2852 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2853 if(!isWasmInitialized) {
2854 throw new Error("initializeWasm() must be awaited first!");
2856 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2857 return nativeResponseValue;
2859 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2861 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2862 if(!isWasmInitialized) {
2863 throw new Error("initializeWasm() must be awaited first!");
2865 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2866 return nativeResponseValue;
2868 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2870 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2871 if(!isWasmInitialized) {
2872 throw new Error("initializeWasm() must be awaited first!");
2874 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2875 // debug statements here
2877 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2879 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2880 if(!isWasmInitialized) {
2881 throw new Error("initializeWasm() must be awaited first!");
2883 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2884 return nativeResponseValue;
2886 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2888 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2889 if(!isWasmInitialized) {
2890 throw new Error("initializeWasm() must be awaited first!");
2892 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2893 // debug statements here
2895 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2897 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2898 if(!isWasmInitialized) {
2899 throw new Error("initializeWasm() must be awaited first!");
2901 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2902 return nativeResponseValue;
2904 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2906 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2907 if(!isWasmInitialized) {
2908 throw new Error("initializeWasm() must be awaited first!");
2910 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2911 return nativeResponseValue;
2913 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2915 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
2916 if(!isWasmInitialized) {
2917 throw new Error("initializeWasm() must be awaited first!");
2919 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
2920 return nativeResponseValue;
2922 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2924 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
2925 if(!isWasmInitialized) {
2926 throw new Error("initializeWasm() must be awaited first!");
2928 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
2929 // debug statements here
2931 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2933 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
2934 if(!isWasmInitialized) {
2935 throw new Error("initializeWasm() must be awaited first!");
2937 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
2938 return nativeResponseValue;
2940 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2942 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
2943 if(!isWasmInitialized) {
2944 throw new Error("initializeWasm() must be awaited first!");
2946 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
2947 // debug statements here
2950 export interface LDKBaseSign {
2951 get_per_commitment_point (idx: bigint): number;
2952 release_commitment_secret (idx: bigint): number;
2953 validate_holder_commitment (holder_tx: number, preimages: number): number;
2954 channel_keys_id (): number;
2955 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
2956 validate_counterparty_revocation (idx: bigint, secret: number): number;
2957 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
2958 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
2959 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
2960 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
2961 sign_closing_transaction (closing_tx: number): number;
2962 sign_channel_announcement (msg: number): number;
2963 ready_channel (channel_parameters: number): void;
2967 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
2968 if(!isWasmInitialized) {
2969 throw new Error("initializeWasm() must be awaited first!");
2971 var new_obj_idx = js_objs.length;
2972 for (var i = 0; i < js_objs.length; i++) {
2973 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2975 js_objs[i] = new WeakRef(impl);
2976 return wasm.TS_LDKBaseSign_new(i);
2978 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2980 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
2981 if(!isWasmInitialized) {
2982 throw new Error("initializeWasm() must be awaited first!");
2984 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
2985 return nativeResponseValue;
2987 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2989 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
2990 if(!isWasmInitialized) {
2991 throw new Error("initializeWasm() must be awaited first!");
2993 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
2994 return nativeResponseValue;
2996 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
2998 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
2999 if(!isWasmInitialized) {
3000 throw new Error("initializeWasm() must be awaited first!");
3002 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3003 return nativeResponseValue;
3005 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3007 export function BaseSign_channel_keys_id(this_arg: number): number {
3008 if(!isWasmInitialized) {
3009 throw new Error("initializeWasm() must be awaited first!");
3011 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3012 return nativeResponseValue;
3014 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3016 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
3017 if(!isWasmInitialized) {
3018 throw new Error("initializeWasm() must be awaited first!");
3020 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3021 return nativeResponseValue;
3023 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3025 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
3026 if(!isWasmInitialized) {
3027 throw new Error("initializeWasm() must be awaited first!");
3029 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3030 return nativeResponseValue;
3032 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3034 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
3035 if(!isWasmInitialized) {
3036 throw new Error("initializeWasm() must be awaited first!");
3038 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3039 return nativeResponseValue;
3041 // 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]
3043 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
3044 if(!isWasmInitialized) {
3045 throw new Error("initializeWasm() must be awaited first!");
3047 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3048 return nativeResponseValue;
3050 // 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
3052 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
3053 if(!isWasmInitialized) {
3054 throw new Error("initializeWasm() must be awaited first!");
3056 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3057 return nativeResponseValue;
3059 // 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
3061 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
3062 if(!isWasmInitialized) {
3063 throw new Error("initializeWasm() must be awaited first!");
3065 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3066 return nativeResponseValue;
3068 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3070 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
3071 if(!isWasmInitialized) {
3072 throw new Error("initializeWasm() must be awaited first!");
3074 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3075 return nativeResponseValue;
3077 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3079 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
3080 if(!isWasmInitialized) {
3081 throw new Error("initializeWasm() must be awaited first!");
3083 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3084 return nativeResponseValue;
3086 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3088 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
3089 if(!isWasmInitialized) {
3090 throw new Error("initializeWasm() must be awaited first!");
3092 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3093 // debug statements here
3095 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3097 export function BaseSign_get_pubkeys(this_arg: number): number {
3098 if(!isWasmInitialized) {
3099 throw new Error("initializeWasm() must be awaited first!");
3101 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3102 return nativeResponseValue;
3105 export interface LDKSign {
3110 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
3111 if(!isWasmInitialized) {
3112 throw new Error("initializeWasm() must be awaited first!");
3114 var new_obj_idx = js_objs.length;
3115 for (var i = 0; i < js_objs.length; i++) {
3116 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3118 js_objs[i] = new WeakRef(impl);
3119 return wasm.TS_LDKSign_new(i);
3121 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3123 export function Sign_write(this_arg: number): number {
3124 if(!isWasmInitialized) {
3125 throw new Error("initializeWasm() must be awaited first!");
3127 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3128 return nativeResponseValue;
3130 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3132 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3133 if(!isWasmInitialized) {
3134 throw new Error("initializeWasm() must be awaited first!");
3136 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3137 return nativeResponseValue;
3139 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3141 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3142 if(!isWasmInitialized) {
3143 throw new Error("initializeWasm() must be awaited first!");
3145 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3146 return nativeResponseValue;
3148 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3150 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3151 if(!isWasmInitialized) {
3152 throw new Error("initializeWasm() must be awaited first!");
3154 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3155 return nativeResponseValue;
3157 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3159 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3160 if(!isWasmInitialized) {
3161 throw new Error("initializeWasm() must be awaited first!");
3163 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3164 // debug statements here
3166 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3168 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3169 if(!isWasmInitialized) {
3170 throw new Error("initializeWasm() must be awaited first!");
3172 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3173 return nativeResponseValue;
3175 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3177 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3178 if(!isWasmInitialized) {
3179 throw new Error("initializeWasm() must be awaited first!");
3181 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3182 // debug statements here
3184 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3186 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3187 if(!isWasmInitialized) {
3188 throw new Error("initializeWasm() must be awaited first!");
3190 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3191 return nativeResponseValue;
3193 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3195 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3196 if(!isWasmInitialized) {
3197 throw new Error("initializeWasm() must be awaited first!");
3199 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3200 return nativeResponseValue;
3202 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3204 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3205 if(!isWasmInitialized) {
3206 throw new Error("initializeWasm() must be awaited first!");
3208 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3209 return nativeResponseValue;
3211 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3213 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3214 if(!isWasmInitialized) {
3215 throw new Error("initializeWasm() must be awaited first!");
3217 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3218 // debug statements here
3221 export class LDKCOption_u16Z {
3222 protected constructor() {}
3225 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3226 if(!isWasmInitialized) {
3227 throw new Error("initializeWasm() must be awaited first!");
3229 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3230 return nativeResponseValue;
3233 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3234 if(!isWasmInitialized) {
3235 throw new Error("initializeWasm() must be awaited first!");
3237 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3238 return nativeResponseValue;
3241 export class LDKAPIError {
3242 protected constructor() {}
3245 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3246 if(!isWasmInitialized) {
3247 throw new Error("initializeWasm() must be awaited first!");
3249 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3250 return nativeResponseValue;
3253 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3254 if(!isWasmInitialized) {
3255 throw new Error("initializeWasm() must be awaited first!");
3257 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3258 return nativeResponseValue;
3261 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3262 if(!isWasmInitialized) {
3263 throw new Error("initializeWasm() must be awaited first!");
3265 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3266 return nativeResponseValue;
3269 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3270 if(!isWasmInitialized) {
3271 throw new Error("initializeWasm() must be awaited first!");
3273 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3274 return nativeResponseValue;
3277 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3278 if(!isWasmInitialized) {
3279 throw new Error("initializeWasm() must be awaited first!");
3281 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3282 return nativeResponseValue;
3285 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3286 if(!isWasmInitialized) {
3287 throw new Error("initializeWasm() must be awaited first!");
3289 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3290 return nativeResponseValue;
3293 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3294 if(!isWasmInitialized) {
3295 throw new Error("initializeWasm() must be awaited first!");
3297 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3298 return nativeResponseValue;
3300 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3302 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3303 if(!isWasmInitialized) {
3304 throw new Error("initializeWasm() must be awaited first!");
3306 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3307 // debug statements here
3309 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3311 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3312 if(!isWasmInitialized) {
3313 throw new Error("initializeWasm() must be awaited first!");
3315 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3316 return nativeResponseValue;
3318 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3320 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3321 if(!isWasmInitialized) {
3322 throw new Error("initializeWasm() must be awaited first!");
3324 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3325 return nativeResponseValue;
3327 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3329 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3330 if(!isWasmInitialized) {
3331 throw new Error("initializeWasm() must be awaited first!");
3333 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3334 return nativeResponseValue;
3337 export class LDKPaymentSendFailure {
3338 protected constructor() {}
3341 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3342 if(!isWasmInitialized) {
3343 throw new Error("initializeWasm() must be awaited first!");
3345 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3346 return nativeResponseValue;
3349 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3350 if(!isWasmInitialized) {
3351 throw new Error("initializeWasm() must be awaited first!");
3353 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3354 return nativeResponseValue;
3357 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
3358 if(!isWasmInitialized) {
3359 throw new Error("initializeWasm() must be awaited first!");
3361 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3362 return nativeResponseValue;
3365 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
3366 if(!isWasmInitialized) {
3367 throw new Error("initializeWasm() must be awaited first!");
3369 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3370 return nativeResponseValue;
3373 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
3374 if(!isWasmInitialized) {
3375 throw new Error("initializeWasm() must be awaited first!");
3377 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3378 return nativeResponseValue;
3381 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
3382 if(!isWasmInitialized) {
3383 throw new Error("initializeWasm() must be awaited first!");
3385 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3386 return nativeResponseValue;
3389 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
3390 if(!isWasmInitialized) {
3391 throw new Error("initializeWasm() must be awaited first!");
3393 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3394 return nativeResponseValue;
3396 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3398 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
3399 if(!isWasmInitialized) {
3400 throw new Error("initializeWasm() must be awaited first!");
3402 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3403 return nativeResponseValue;
3405 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3407 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
3408 if(!isWasmInitialized) {
3409 throw new Error("initializeWasm() must be awaited first!");
3411 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3412 return nativeResponseValue;
3414 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3416 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
3417 if(!isWasmInitialized) {
3418 throw new Error("initializeWasm() must be awaited first!");
3420 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3421 // debug statements here
3423 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3425 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
3426 if(!isWasmInitialized) {
3427 throw new Error("initializeWasm() must be awaited first!");
3429 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3430 return nativeResponseValue;
3432 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3434 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
3435 if(!isWasmInitialized) {
3436 throw new Error("initializeWasm() must be awaited first!");
3438 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3439 return nativeResponseValue;
3441 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3443 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
3444 if(!isWasmInitialized) {
3445 throw new Error("initializeWasm() must be awaited first!");
3447 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3448 return nativeResponseValue;
3450 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3452 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
3453 if(!isWasmInitialized) {
3454 throw new Error("initializeWasm() must be awaited first!");
3456 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3457 return nativeResponseValue;
3459 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3461 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
3462 if(!isWasmInitialized) {
3463 throw new Error("initializeWasm() must be awaited first!");
3465 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3466 return nativeResponseValue;
3468 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3470 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3471 if(!isWasmInitialized) {
3472 throw new Error("initializeWasm() must be awaited first!");
3474 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3475 return nativeResponseValue;
3477 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3479 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3480 if(!isWasmInitialized) {
3481 throw new Error("initializeWasm() must be awaited first!");
3483 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3484 return nativeResponseValue;
3486 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3488 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3489 if(!isWasmInitialized) {
3490 throw new Error("initializeWasm() must be awaited first!");
3492 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3493 return nativeResponseValue;
3495 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3497 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3498 if(!isWasmInitialized) {
3499 throw new Error("initializeWasm() must be awaited first!");
3501 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3502 // debug statements here
3504 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3506 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3507 if(!isWasmInitialized) {
3508 throw new Error("initializeWasm() must be awaited first!");
3510 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3511 return nativeResponseValue;
3513 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3515 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3516 if(!isWasmInitialized) {
3517 throw new Error("initializeWasm() must be awaited first!");
3519 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3520 return nativeResponseValue;
3522 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3524 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3525 if(!isWasmInitialized) {
3526 throw new Error("initializeWasm() must be awaited first!");
3528 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3529 return nativeResponseValue;
3531 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3533 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3534 if(!isWasmInitialized) {
3535 throw new Error("initializeWasm() must be awaited first!");
3537 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3538 // debug statements here
3540 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3542 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3543 if(!isWasmInitialized) {
3544 throw new Error("initializeWasm() must be awaited first!");
3546 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3547 return nativeResponseValue;
3549 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3551 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3552 if(!isWasmInitialized) {
3553 throw new Error("initializeWasm() must be awaited first!");
3555 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3556 return nativeResponseValue;
3558 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3560 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3561 if(!isWasmInitialized) {
3562 throw new Error("initializeWasm() must be awaited first!");
3564 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3565 return nativeResponseValue;
3567 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3569 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3570 if(!isWasmInitialized) {
3571 throw new Error("initializeWasm() must be awaited first!");
3573 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3574 return nativeResponseValue;
3576 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3578 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3579 if(!isWasmInitialized) {
3580 throw new Error("initializeWasm() must be awaited first!");
3582 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3583 return nativeResponseValue;
3585 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3587 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3588 if(!isWasmInitialized) {
3589 throw new Error("initializeWasm() must be awaited first!");
3591 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3592 return nativeResponseValue;
3594 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3596 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3597 if(!isWasmInitialized) {
3598 throw new Error("initializeWasm() must be awaited first!");
3600 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3601 return nativeResponseValue;
3603 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3605 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3606 if(!isWasmInitialized) {
3607 throw new Error("initializeWasm() must be awaited first!");
3609 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3610 return nativeResponseValue;
3612 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3614 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3615 if(!isWasmInitialized) {
3616 throw new Error("initializeWasm() must be awaited first!");
3618 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3619 return nativeResponseValue;
3621 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3623 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3624 if(!isWasmInitialized) {
3625 throw new Error("initializeWasm() must be awaited first!");
3627 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3628 return nativeResponseValue;
3630 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3632 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3633 if(!isWasmInitialized) {
3634 throw new Error("initializeWasm() must be awaited first!");
3636 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3637 return nativeResponseValue;
3639 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3641 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3642 if(!isWasmInitialized) {
3643 throw new Error("initializeWasm() must be awaited first!");
3645 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3646 return nativeResponseValue;
3649 export interface LDKWatch {
3650 watch_channel (funding_txo: number, monitor: number): number;
3651 update_channel (funding_txo: number, update: number): number;
3652 release_pending_monitor_events (): number;
3656 export function LDKWatch_new(impl: LDKWatch): number {
3657 if(!isWasmInitialized) {
3658 throw new Error("initializeWasm() must be awaited first!");
3660 var new_obj_idx = js_objs.length;
3661 for (var i = 0; i < js_objs.length; i++) {
3662 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3664 js_objs[i] = new WeakRef(impl);
3665 return wasm.TS_LDKWatch_new(i);
3667 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3669 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3670 if(!isWasmInitialized) {
3671 throw new Error("initializeWasm() must be awaited first!");
3673 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3674 return nativeResponseValue;
3676 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3678 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3679 if(!isWasmInitialized) {
3680 throw new Error("initializeWasm() must be awaited first!");
3682 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3683 return nativeResponseValue;
3685 // LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3687 export function Watch_release_pending_monitor_events(this_arg: number): number {
3688 if(!isWasmInitialized) {
3689 throw new Error("initializeWasm() must be awaited first!");
3691 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3692 return nativeResponseValue;
3695 export interface LDKBroadcasterInterface {
3696 broadcast_transaction (tx: number): void;
3700 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3701 if(!isWasmInitialized) {
3702 throw new Error("initializeWasm() must be awaited first!");
3704 var new_obj_idx = js_objs.length;
3705 for (var i = 0; i < js_objs.length; i++) {
3706 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3708 js_objs[i] = new WeakRef(impl);
3709 return wasm.TS_LDKBroadcasterInterface_new(i);
3711 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3713 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3714 if(!isWasmInitialized) {
3715 throw new Error("initializeWasm() must be awaited first!");
3717 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3718 // debug statements here
3721 export interface LDKKeysInterface {
3722 get_node_secret (recipient: Recipient): number;
3723 get_destination_script (): number;
3724 get_shutdown_scriptpubkey (): number;
3725 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3726 get_secure_random_bytes (): number;
3727 read_chan_signer (reader: number): number;
3728 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3729 get_inbound_payment_key_material (): number;
3733 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3734 if(!isWasmInitialized) {
3735 throw new Error("initializeWasm() must be awaited first!");
3737 var new_obj_idx = js_objs.length;
3738 for (var i = 0; i < js_objs.length; i++) {
3739 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3741 js_objs[i] = new WeakRef(impl);
3742 return wasm.TS_LDKKeysInterface_new(i);
3744 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3746 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3747 if(!isWasmInitialized) {
3748 throw new Error("initializeWasm() must be awaited first!");
3750 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3751 return nativeResponseValue;
3753 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3755 export function KeysInterface_get_destination_script(this_arg: number): number {
3756 if(!isWasmInitialized) {
3757 throw new Error("initializeWasm() must be awaited first!");
3759 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3760 return nativeResponseValue;
3762 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3764 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3765 if(!isWasmInitialized) {
3766 throw new Error("initializeWasm() must be awaited first!");
3768 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3769 return nativeResponseValue;
3771 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3773 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3774 if(!isWasmInitialized) {
3775 throw new Error("initializeWasm() must be awaited first!");
3777 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3778 return nativeResponseValue;
3780 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3782 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3783 if(!isWasmInitialized) {
3784 throw new Error("initializeWasm() must be awaited first!");
3786 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3787 return nativeResponseValue;
3789 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3791 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3792 if(!isWasmInitialized) {
3793 throw new Error("initializeWasm() must be awaited first!");
3795 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3796 return nativeResponseValue;
3798 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3800 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3801 if(!isWasmInitialized) {
3802 throw new Error("initializeWasm() must be awaited first!");
3804 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3805 return nativeResponseValue;
3807 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3809 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3810 if(!isWasmInitialized) {
3811 throw new Error("initializeWasm() must be awaited first!");
3813 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3814 return nativeResponseValue;
3817 export interface LDKFeeEstimator {
3818 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3822 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3823 if(!isWasmInitialized) {
3824 throw new Error("initializeWasm() must be awaited first!");
3826 var new_obj_idx = js_objs.length;
3827 for (var i = 0; i < js_objs.length; i++) {
3828 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3830 js_objs[i] = new WeakRef(impl);
3831 return wasm.TS_LDKFeeEstimator_new(i);
3833 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3835 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3836 if(!isWasmInitialized) {
3837 throw new Error("initializeWasm() must be awaited first!");
3839 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3840 return nativeResponseValue;
3842 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3844 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3845 if(!isWasmInitialized) {
3846 throw new Error("initializeWasm() must be awaited first!");
3848 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3849 return nativeResponseValue;
3851 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3853 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3854 if(!isWasmInitialized) {
3855 throw new Error("initializeWasm() must be awaited first!");
3857 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3858 return nativeResponseValue;
3860 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3862 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3863 if(!isWasmInitialized) {
3864 throw new Error("initializeWasm() must be awaited first!");
3866 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3867 return nativeResponseValue;
3869 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3871 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3872 if(!isWasmInitialized) {
3873 throw new Error("initializeWasm() must be awaited first!");
3875 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3876 return nativeResponseValue;
3878 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3880 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3881 if(!isWasmInitialized) {
3882 throw new Error("initializeWasm() must be awaited first!");
3884 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3885 return nativeResponseValue;
3887 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3889 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3890 if(!isWasmInitialized) {
3891 throw new Error("initializeWasm() must be awaited first!");
3893 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3894 return nativeResponseValue;
3896 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3898 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3899 if(!isWasmInitialized) {
3900 throw new Error("initializeWasm() must be awaited first!");
3902 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3903 return nativeResponseValue;
3905 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3907 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3908 if(!isWasmInitialized) {
3909 throw new Error("initializeWasm() must be awaited first!");
3911 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3912 return nativeResponseValue;
3915 export interface LDKType {
3917 debug_str (): number;
3922 export function LDKType_new(impl: LDKType): number {
3923 if(!isWasmInitialized) {
3924 throw new Error("initializeWasm() must be awaited first!");
3926 var new_obj_idx = js_objs.length;
3927 for (var i = 0; i < js_objs.length; i++) {
3928 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3930 js_objs[i] = new WeakRef(impl);
3931 return wasm.TS_LDKType_new(i);
3933 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
3935 export function Type_type_id(this_arg: number): number {
3936 if(!isWasmInitialized) {
3937 throw new Error("initializeWasm() must be awaited first!");
3939 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
3940 return nativeResponseValue;
3942 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
3944 export function Type_debug_str(this_arg: number): number {
3945 if(!isWasmInitialized) {
3946 throw new Error("initializeWasm() must be awaited first!");
3948 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
3949 return nativeResponseValue;
3951 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
3953 export function Type_write(this_arg: number): number {
3954 if(!isWasmInitialized) {
3955 throw new Error("initializeWasm() must be awaited first!");
3957 const nativeResponseValue = wasm.TS_Type_write(this_arg);
3958 return nativeResponseValue;
3961 export class LDKCOption_TypeZ {
3962 protected constructor() {}
3965 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
3966 if(!isWasmInitialized) {
3967 throw new Error("initializeWasm() must be awaited first!");
3969 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
3970 return nativeResponseValue;
3973 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
3974 if(!isWasmInitialized) {
3975 throw new Error("initializeWasm() must be awaited first!");
3977 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
3978 return nativeResponseValue;
3980 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3982 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
3983 if(!isWasmInitialized) {
3984 throw new Error("initializeWasm() must be awaited first!");
3986 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
3987 return nativeResponseValue;
3989 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3991 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
3992 if(!isWasmInitialized) {
3993 throw new Error("initializeWasm() must be awaited first!");
3995 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
3996 return nativeResponseValue;
3999 export class LDKPaymentError {
4000 protected constructor() {}
4003 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
4004 if(!isWasmInitialized) {
4005 throw new Error("initializeWasm() must be awaited first!");
4007 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4008 return nativeResponseValue;
4011 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
4012 if(!isWasmInitialized) {
4013 throw new Error("initializeWasm() must be awaited first!");
4015 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4016 return nativeResponseValue;
4019 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
4020 if(!isWasmInitialized) {
4021 throw new Error("initializeWasm() must be awaited first!");
4023 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4024 return nativeResponseValue;
4027 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
4028 if(!isWasmInitialized) {
4029 throw new Error("initializeWasm() must be awaited first!");
4031 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4032 return nativeResponseValue;
4034 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4036 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
4037 if(!isWasmInitialized) {
4038 throw new Error("initializeWasm() must be awaited first!");
4040 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4041 return nativeResponseValue;
4043 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4045 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
4046 if(!isWasmInitialized) {
4047 throw new Error("initializeWasm() must be awaited first!");
4049 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4050 return nativeResponseValue;
4053 export class LDKParseError {
4054 protected constructor() {}
4057 export function LDKParseError_ty_from_ptr(ptr: number): number {
4058 if(!isWasmInitialized) {
4059 throw new Error("initializeWasm() must be awaited first!");
4061 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4062 return nativeResponseValue;
4065 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
4066 if(!isWasmInitialized) {
4067 throw new Error("initializeWasm() must be awaited first!");
4069 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4070 return nativeResponseValue;
4073 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
4074 if(!isWasmInitialized) {
4075 throw new Error("initializeWasm() must be awaited first!");
4077 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4078 return nativeResponseValue;
4081 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
4082 if(!isWasmInitialized) {
4083 throw new Error("initializeWasm() must be awaited first!");
4085 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4086 return nativeResponseValue;
4089 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
4090 if(!isWasmInitialized) {
4091 throw new Error("initializeWasm() must be awaited first!");
4093 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4094 return nativeResponseValue;
4097 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
4098 if(!isWasmInitialized) {
4099 throw new Error("initializeWasm() must be awaited first!");
4101 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4102 return nativeResponseValue;
4104 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4106 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
4107 if(!isWasmInitialized) {
4108 throw new Error("initializeWasm() must be awaited first!");
4110 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4111 return nativeResponseValue;
4113 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4115 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
4116 if(!isWasmInitialized) {
4117 throw new Error("initializeWasm() must be awaited first!");
4119 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4120 return nativeResponseValue;
4123 export class LDKParseOrSemanticError {
4124 protected constructor() {}
4127 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
4128 if(!isWasmInitialized) {
4129 throw new Error("initializeWasm() must be awaited first!");
4131 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4132 return nativeResponseValue;
4135 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
4136 if(!isWasmInitialized) {
4137 throw new Error("initializeWasm() must be awaited first!");
4139 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4140 return nativeResponseValue;
4143 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
4144 if(!isWasmInitialized) {
4145 throw new Error("initializeWasm() must be awaited first!");
4147 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4148 return nativeResponseValue;
4150 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4152 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
4153 if(!isWasmInitialized) {
4154 throw new Error("initializeWasm() must be awaited first!");
4156 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4157 return nativeResponseValue;
4159 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4161 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
4162 if(!isWasmInitialized) {
4163 throw new Error("initializeWasm() must be awaited first!");
4165 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4166 return nativeResponseValue;
4168 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4170 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
4171 if(!isWasmInitialized) {
4172 throw new Error("initializeWasm() must be awaited first!");
4174 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4175 return nativeResponseValue;
4177 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4179 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
4180 if(!isWasmInitialized) {
4181 throw new Error("initializeWasm() must be awaited first!");
4183 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4184 return nativeResponseValue;
4186 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4188 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
4189 if(!isWasmInitialized) {
4190 throw new Error("initializeWasm() must be awaited first!");
4192 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4193 return nativeResponseValue;
4195 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4197 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
4198 if(!isWasmInitialized) {
4199 throw new Error("initializeWasm() must be awaited first!");
4201 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4202 return nativeResponseValue;
4204 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4206 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
4207 if(!isWasmInitialized) {
4208 throw new Error("initializeWasm() must be awaited first!");
4210 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4211 return nativeResponseValue;
4213 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4215 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
4216 if(!isWasmInitialized) {
4217 throw new Error("initializeWasm() must be awaited first!");
4219 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4220 return nativeResponseValue;
4222 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4224 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
4225 if(!isWasmInitialized) {
4226 throw new Error("initializeWasm() must be awaited first!");
4228 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4229 return nativeResponseValue;
4231 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4233 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
4234 if(!isWasmInitialized) {
4235 throw new Error("initializeWasm() must be awaited first!");
4237 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4238 return nativeResponseValue;
4240 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4242 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
4243 if(!isWasmInitialized) {
4244 throw new Error("initializeWasm() must be awaited first!");
4246 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4247 return nativeResponseValue;
4249 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4251 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
4252 if(!isWasmInitialized) {
4253 throw new Error("initializeWasm() must be awaited first!");
4255 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4256 // debug statements here
4258 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4260 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
4261 if(!isWasmInitialized) {
4262 throw new Error("initializeWasm() must be awaited first!");
4264 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4265 return nativeResponseValue;
4267 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4269 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
4270 if(!isWasmInitialized) {
4271 throw new Error("initializeWasm() must be awaited first!");
4273 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4274 return nativeResponseValue;
4276 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4278 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
4279 if(!isWasmInitialized) {
4280 throw new Error("initializeWasm() must be awaited first!");
4282 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4283 return nativeResponseValue;
4285 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4287 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
4288 if(!isWasmInitialized) {
4289 throw new Error("initializeWasm() must be awaited first!");
4291 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4292 return nativeResponseValue;
4294 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4296 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
4297 if(!isWasmInitialized) {
4298 throw new Error("initializeWasm() must be awaited first!");
4300 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4301 return nativeResponseValue;
4303 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4305 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
4306 if(!isWasmInitialized) {
4307 throw new Error("initializeWasm() must be awaited first!");
4309 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4310 return nativeResponseValue;
4312 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4314 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
4315 if(!isWasmInitialized) {
4316 throw new Error("initializeWasm() must be awaited first!");
4318 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4319 return nativeResponseValue;
4321 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4323 export function CResult_StringErrorZ_get_ok(owner: number): number {
4324 if(!isWasmInitialized) {
4325 throw new Error("initializeWasm() must be awaited first!");
4327 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4328 return nativeResponseValue;
4330 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4332 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
4333 if(!isWasmInitialized) {
4334 throw new Error("initializeWasm() must be awaited first!");
4336 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4337 return nativeResponseValue;
4339 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4341 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
4342 if(!isWasmInitialized) {
4343 throw new Error("initializeWasm() must be awaited first!");
4345 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4346 return nativeResponseValue;
4348 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4350 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
4351 if(!isWasmInitialized) {
4352 throw new Error("initializeWasm() must be awaited first!");
4354 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4355 return nativeResponseValue;
4358 export class LDKCOption_MonitorEventZ {
4359 protected constructor() {}
4362 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
4363 if(!isWasmInitialized) {
4364 throw new Error("initializeWasm() must be awaited first!");
4366 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4367 return nativeResponseValue;
4370 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4371 if(!isWasmInitialized) {
4372 throw new Error("initializeWasm() must be awaited first!");
4374 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4375 return nativeResponseValue;
4377 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4379 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4380 if(!isWasmInitialized) {
4381 throw new Error("initializeWasm() must be awaited first!");
4383 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4384 return nativeResponseValue;
4386 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4388 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4389 if(!isWasmInitialized) {
4390 throw new Error("initializeWasm() must be awaited first!");
4392 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4393 return nativeResponseValue;
4395 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4397 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4398 if(!isWasmInitialized) {
4399 throw new Error("initializeWasm() must be awaited first!");
4401 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4402 return nativeResponseValue;
4404 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4406 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4407 if(!isWasmInitialized) {
4408 throw new Error("initializeWasm() must be awaited first!");
4410 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4411 return nativeResponseValue;
4413 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4415 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4416 if(!isWasmInitialized) {
4417 throw new Error("initializeWasm() must be awaited first!");
4419 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4420 return nativeResponseValue;
4422 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4424 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4425 if(!isWasmInitialized) {
4426 throw new Error("initializeWasm() must be awaited first!");
4428 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4429 return nativeResponseValue;
4431 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4433 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4434 if(!isWasmInitialized) {
4435 throw new Error("initializeWasm() must be awaited first!");
4437 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4438 return nativeResponseValue;
4440 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4442 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4443 if(!isWasmInitialized) {
4444 throw new Error("initializeWasm() must be awaited first!");
4446 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4447 return nativeResponseValue;
4449 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4451 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4452 if(!isWasmInitialized) {
4453 throw new Error("initializeWasm() must be awaited first!");
4455 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4456 return nativeResponseValue;
4458 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4460 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4461 if(!isWasmInitialized) {
4462 throw new Error("initializeWasm() must be awaited first!");
4464 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4465 return nativeResponseValue;
4467 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4469 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4470 if(!isWasmInitialized) {
4471 throw new Error("initializeWasm() must be awaited first!");
4473 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4474 return nativeResponseValue;
4476 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4478 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4479 if(!isWasmInitialized) {
4480 throw new Error("initializeWasm() must be awaited first!");
4482 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4483 return nativeResponseValue;
4485 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4487 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4488 if(!isWasmInitialized) {
4489 throw new Error("initializeWasm() must be awaited first!");
4491 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4492 return nativeResponseValue;
4494 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4496 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4497 if(!isWasmInitialized) {
4498 throw new Error("initializeWasm() must be awaited first!");
4500 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4501 return nativeResponseValue;
4504 export class LDKBalance {
4505 protected constructor() {}
4508 export function LDKBalance_ty_from_ptr(ptr: number): number {
4509 if(!isWasmInitialized) {
4510 throw new Error("initializeWasm() must be awaited first!");
4512 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4513 return nativeResponseValue;
4516 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4517 if(!isWasmInitialized) {
4518 throw new Error("initializeWasm() must be awaited first!");
4520 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4521 return nativeResponseValue;
4524 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4525 if(!isWasmInitialized) {
4526 throw new Error("initializeWasm() must be awaited first!");
4528 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4529 return nativeResponseValue;
4532 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4533 if(!isWasmInitialized) {
4534 throw new Error("initializeWasm() must be awaited first!");
4536 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4537 return nativeResponseValue;
4540 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4541 if(!isWasmInitialized) {
4542 throw new Error("initializeWasm() must be awaited first!");
4544 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4545 return nativeResponseValue;
4548 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4549 if(!isWasmInitialized) {
4550 throw new Error("initializeWasm() must be awaited first!");
4552 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4553 return nativeResponseValue;
4556 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4557 if(!isWasmInitialized) {
4558 throw new Error("initializeWasm() must be awaited first!");
4560 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4561 return nativeResponseValue;
4564 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4565 if(!isWasmInitialized) {
4566 throw new Error("initializeWasm() must be awaited first!");
4568 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4569 return nativeResponseValue;
4571 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4573 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4574 if(!isWasmInitialized) {
4575 throw new Error("initializeWasm() must be awaited first!");
4577 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4578 return nativeResponseValue;
4580 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4582 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4583 if(!isWasmInitialized) {
4584 throw new Error("initializeWasm() must be awaited first!");
4586 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4587 return nativeResponseValue;
4589 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4591 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4592 if(!isWasmInitialized) {
4593 throw new Error("initializeWasm() must be awaited first!");
4595 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4596 return nativeResponseValue;
4598 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4600 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4601 if(!isWasmInitialized) {
4602 throw new Error("initializeWasm() must be awaited first!");
4604 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4605 return nativeResponseValue;
4607 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4609 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4610 if(!isWasmInitialized) {
4611 throw new Error("initializeWasm() must be awaited first!");
4613 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4614 return nativeResponseValue;
4616 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4618 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4619 if(!isWasmInitialized) {
4620 throw new Error("initializeWasm() must be awaited first!");
4622 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4623 return nativeResponseValue;
4626 export class LDKCOption_NetAddressZ {
4627 protected constructor() {}
4630 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4631 if(!isWasmInitialized) {
4632 throw new Error("initializeWasm() must be awaited first!");
4634 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4635 return nativeResponseValue;
4638 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4639 if(!isWasmInitialized) {
4640 throw new Error("initializeWasm() must be awaited first!");
4642 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4643 return nativeResponseValue;
4645 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4647 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4648 if(!isWasmInitialized) {
4649 throw new Error("initializeWasm() must be awaited first!");
4651 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4652 return nativeResponseValue;
4654 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4656 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4657 if(!isWasmInitialized) {
4658 throw new Error("initializeWasm() must be awaited first!");
4660 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4661 return nativeResponseValue;
4663 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4665 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4666 if(!isWasmInitialized) {
4667 throw new Error("initializeWasm() must be awaited first!");
4669 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4670 // debug statements here
4672 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4674 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4675 if(!isWasmInitialized) {
4676 throw new Error("initializeWasm() must be awaited first!");
4678 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4679 return nativeResponseValue;
4681 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4683 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4684 if(!isWasmInitialized) {
4685 throw new Error("initializeWasm() must be awaited first!");
4687 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4688 return nativeResponseValue;
4690 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4692 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4693 if(!isWasmInitialized) {
4694 throw new Error("initializeWasm() must be awaited first!");
4696 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4697 return nativeResponseValue;
4699 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4701 export function CResult_NoneErrorZ_get_ok(owner: number): void {
4702 if(!isWasmInitialized) {
4703 throw new Error("initializeWasm() must be awaited first!");
4705 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4706 // debug statements here
4708 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4710 export function CResult_NoneErrorZ_get_err(owner: number): IOError {
4711 if(!isWasmInitialized) {
4712 throw new Error("initializeWasm() must be awaited first!");
4714 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
4715 return nativeResponseValue;
4717 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4719 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4720 if(!isWasmInitialized) {
4721 throw new Error("initializeWasm() must be awaited first!");
4723 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4724 return nativeResponseValue;
4726 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4728 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4729 if(!isWasmInitialized) {
4730 throw new Error("initializeWasm() must be awaited first!");
4732 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4733 return nativeResponseValue;
4735 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4737 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4738 if(!isWasmInitialized) {
4739 throw new Error("initializeWasm() must be awaited first!");
4741 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4742 return nativeResponseValue;
4744 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4746 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4747 if(!isWasmInitialized) {
4748 throw new Error("initializeWasm() must be awaited first!");
4750 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4751 return nativeResponseValue;
4753 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4755 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4756 if(!isWasmInitialized) {
4757 throw new Error("initializeWasm() must be awaited first!");
4759 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4760 return nativeResponseValue;
4762 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4764 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4765 if(!isWasmInitialized) {
4766 throw new Error("initializeWasm() must be awaited first!");
4768 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4769 return nativeResponseValue;
4771 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4773 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4774 if(!isWasmInitialized) {
4775 throw new Error("initializeWasm() must be awaited first!");
4777 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4778 return nativeResponseValue;
4780 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4782 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4783 if(!isWasmInitialized) {
4784 throw new Error("initializeWasm() must be awaited first!");
4786 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4787 return nativeResponseValue;
4789 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4791 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4792 if(!isWasmInitialized) {
4793 throw new Error("initializeWasm() must be awaited first!");
4795 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4796 return nativeResponseValue;
4798 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4800 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4801 if(!isWasmInitialized) {
4802 throw new Error("initializeWasm() must be awaited first!");
4804 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4805 return nativeResponseValue;
4807 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4809 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4810 if(!isWasmInitialized) {
4811 throw new Error("initializeWasm() must be awaited first!");
4813 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4814 return nativeResponseValue;
4816 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4818 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4819 if(!isWasmInitialized) {
4820 throw new Error("initializeWasm() must be awaited first!");
4822 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4823 return nativeResponseValue;
4825 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4827 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4828 if(!isWasmInitialized) {
4829 throw new Error("initializeWasm() must be awaited first!");
4831 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4832 return nativeResponseValue;
4834 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4836 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4837 if(!isWasmInitialized) {
4838 throw new Error("initializeWasm() must be awaited first!");
4840 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4841 return nativeResponseValue;
4843 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4845 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4846 if(!isWasmInitialized) {
4847 throw new Error("initializeWasm() must be awaited first!");
4849 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4850 return nativeResponseValue;
4852 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4854 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4855 if(!isWasmInitialized) {
4856 throw new Error("initializeWasm() must be awaited first!");
4858 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4859 return nativeResponseValue;
4861 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4863 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4864 if(!isWasmInitialized) {
4865 throw new Error("initializeWasm() must be awaited first!");
4867 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4868 return nativeResponseValue;
4870 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4872 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4873 if(!isWasmInitialized) {
4874 throw new Error("initializeWasm() must be awaited first!");
4876 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4877 return nativeResponseValue;
4879 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4881 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: number): number {
4882 if(!isWasmInitialized) {
4883 throw new Error("initializeWasm() must be awaited first!");
4885 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
4886 return nativeResponseValue;
4888 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4890 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: number): number {
4891 if(!isWasmInitialized) {
4892 throw new Error("initializeWasm() must be awaited first!");
4894 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
4895 return nativeResponseValue;
4897 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4899 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4900 if(!isWasmInitialized) {
4901 throw new Error("initializeWasm() must be awaited first!");
4903 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4904 return nativeResponseValue;
4906 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4908 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4909 if(!isWasmInitialized) {
4910 throw new Error("initializeWasm() must be awaited first!");
4912 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4913 return nativeResponseValue;
4915 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4917 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
4918 if(!isWasmInitialized) {
4919 throw new Error("initializeWasm() must be awaited first!");
4921 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
4922 return nativeResponseValue;
4924 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4926 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
4927 if(!isWasmInitialized) {
4928 throw new Error("initializeWasm() must be awaited first!");
4930 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
4931 return nativeResponseValue;
4933 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4935 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
4936 if(!isWasmInitialized) {
4937 throw new Error("initializeWasm() must be awaited first!");
4939 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
4940 return nativeResponseValue;
4942 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4944 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
4945 if(!isWasmInitialized) {
4946 throw new Error("initializeWasm() must be awaited first!");
4948 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
4949 return nativeResponseValue;
4951 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4953 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
4954 if(!isWasmInitialized) {
4955 throw new Error("initializeWasm() must be awaited first!");
4957 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
4958 return nativeResponseValue;
4960 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4962 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
4963 if(!isWasmInitialized) {
4964 throw new Error("initializeWasm() must be awaited first!");
4966 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
4967 return nativeResponseValue;
4969 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4971 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
4972 if(!isWasmInitialized) {
4973 throw new Error("initializeWasm() must be awaited first!");
4975 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
4976 return nativeResponseValue;
4978 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4980 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
4981 if(!isWasmInitialized) {
4982 throw new Error("initializeWasm() must be awaited first!");
4984 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
4985 return nativeResponseValue;
4987 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4989 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
4990 if(!isWasmInitialized) {
4991 throw new Error("initializeWasm() must be awaited first!");
4993 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
4994 return nativeResponseValue;
4996 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4998 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
4999 if(!isWasmInitialized) {
5000 throw new Error("initializeWasm() must be awaited first!");
5002 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5003 return nativeResponseValue;
5005 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5007 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
5008 if(!isWasmInitialized) {
5009 throw new Error("initializeWasm() must be awaited first!");
5011 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5012 return nativeResponseValue;
5014 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5016 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
5017 if(!isWasmInitialized) {
5018 throw new Error("initializeWasm() must be awaited first!");
5020 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5021 return nativeResponseValue;
5023 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5025 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
5026 if(!isWasmInitialized) {
5027 throw new Error("initializeWasm() must be awaited first!");
5029 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5030 return nativeResponseValue;
5032 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5034 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
5035 if(!isWasmInitialized) {
5036 throw new Error("initializeWasm() must be awaited first!");
5038 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5039 return nativeResponseValue;
5041 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5043 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
5044 if(!isWasmInitialized) {
5045 throw new Error("initializeWasm() must be awaited first!");
5047 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5048 return nativeResponseValue;
5050 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5052 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
5053 if(!isWasmInitialized) {
5054 throw new Error("initializeWasm() must be awaited first!");
5056 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5057 return nativeResponseValue;
5059 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5061 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
5062 if(!isWasmInitialized) {
5063 throw new Error("initializeWasm() must be awaited first!");
5065 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5066 return nativeResponseValue;
5068 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5070 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
5071 if(!isWasmInitialized) {
5072 throw new Error("initializeWasm() must be awaited first!");
5074 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5075 return nativeResponseValue;
5077 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5079 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
5080 if(!isWasmInitialized) {
5081 throw new Error("initializeWasm() must be awaited first!");
5083 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5084 return nativeResponseValue;
5086 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5088 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
5089 if(!isWasmInitialized) {
5090 throw new Error("initializeWasm() must be awaited first!");
5092 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5093 return nativeResponseValue;
5095 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5097 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5098 if(!isWasmInitialized) {
5099 throw new Error("initializeWasm() must be awaited first!");
5101 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5102 return nativeResponseValue;
5104 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5106 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5107 if(!isWasmInitialized) {
5108 throw new Error("initializeWasm() must be awaited first!");
5110 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5111 return nativeResponseValue;
5113 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5115 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5116 if(!isWasmInitialized) {
5117 throw new Error("initializeWasm() must be awaited first!");
5119 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5120 return nativeResponseValue;
5122 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5124 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5125 if(!isWasmInitialized) {
5126 throw new Error("initializeWasm() must be awaited first!");
5128 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5129 return nativeResponseValue;
5131 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5133 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5134 if(!isWasmInitialized) {
5135 throw new Error("initializeWasm() must be awaited first!");
5137 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5138 return nativeResponseValue;
5140 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5142 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5143 if(!isWasmInitialized) {
5144 throw new Error("initializeWasm() must be awaited first!");
5146 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5147 return nativeResponseValue;
5149 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5151 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5152 if(!isWasmInitialized) {
5153 throw new Error("initializeWasm() must be awaited first!");
5155 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5156 return nativeResponseValue;
5158 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5160 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5161 if(!isWasmInitialized) {
5162 throw new Error("initializeWasm() must be awaited first!");
5164 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5165 return nativeResponseValue;
5167 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5169 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5170 if(!isWasmInitialized) {
5171 throw new Error("initializeWasm() must be awaited first!");
5173 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5174 return nativeResponseValue;
5176 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5178 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5179 if(!isWasmInitialized) {
5180 throw new Error("initializeWasm() must be awaited first!");
5182 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5183 return nativeResponseValue;
5185 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5187 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5188 if(!isWasmInitialized) {
5189 throw new Error("initializeWasm() must be awaited first!");
5191 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5192 return nativeResponseValue;
5194 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5196 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5197 if(!isWasmInitialized) {
5198 throw new Error("initializeWasm() must be awaited first!");
5200 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5201 return nativeResponseValue;
5203 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5205 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5206 if(!isWasmInitialized) {
5207 throw new Error("initializeWasm() must be awaited first!");
5209 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5210 return nativeResponseValue;
5212 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5214 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5215 if(!isWasmInitialized) {
5216 throw new Error("initializeWasm() must be awaited first!");
5218 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5219 return nativeResponseValue;
5221 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5223 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5224 if(!isWasmInitialized) {
5225 throw new Error("initializeWasm() must be awaited first!");
5227 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5228 return nativeResponseValue;
5230 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5232 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5233 if(!isWasmInitialized) {
5234 throw new Error("initializeWasm() must be awaited first!");
5236 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5237 return nativeResponseValue;
5239 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5241 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5242 if(!isWasmInitialized) {
5243 throw new Error("initializeWasm() must be awaited first!");
5245 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5246 return nativeResponseValue;
5248 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5250 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5251 if(!isWasmInitialized) {
5252 throw new Error("initializeWasm() must be awaited first!");
5254 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5255 return nativeResponseValue;
5257 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5259 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5260 if(!isWasmInitialized) {
5261 throw new Error("initializeWasm() must be awaited first!");
5263 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5264 return nativeResponseValue;
5266 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5268 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5269 if(!isWasmInitialized) {
5270 throw new Error("initializeWasm() must be awaited first!");
5272 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5273 return nativeResponseValue;
5275 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5277 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5278 if(!isWasmInitialized) {
5279 throw new Error("initializeWasm() must be awaited first!");
5281 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5282 return nativeResponseValue;
5284 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5286 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5287 if(!isWasmInitialized) {
5288 throw new Error("initializeWasm() must be awaited first!");
5290 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5291 return nativeResponseValue;
5293 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5295 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5296 if(!isWasmInitialized) {
5297 throw new Error("initializeWasm() must be awaited first!");
5299 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5300 return nativeResponseValue;
5302 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5304 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5305 if(!isWasmInitialized) {
5306 throw new Error("initializeWasm() must be awaited first!");
5308 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5309 return nativeResponseValue;
5311 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5313 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5314 if(!isWasmInitialized) {
5315 throw new Error("initializeWasm() must be awaited first!");
5317 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5318 return nativeResponseValue;
5320 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5322 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5323 if(!isWasmInitialized) {
5324 throw new Error("initializeWasm() must be awaited first!");
5326 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5327 return nativeResponseValue;
5330 export class LDKSignOrCreationError {
5331 protected constructor() {}
5334 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5335 if(!isWasmInitialized) {
5336 throw new Error("initializeWasm() must be awaited first!");
5338 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5339 return nativeResponseValue;
5342 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5343 if(!isWasmInitialized) {
5344 throw new Error("initializeWasm() must be awaited first!");
5346 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5347 return nativeResponseValue;
5349 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5351 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5352 if(!isWasmInitialized) {
5353 throw new Error("initializeWasm() must be awaited first!");
5355 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5356 return nativeResponseValue;
5358 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5360 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5365 return nativeResponseValue;
5368 export interface LDKFilter {
5369 register_tx (txid: number, script_pubkey: number): void;
5370 register_output (output: number): number;
5374 export function LDKFilter_new(impl: LDKFilter): number {
5375 if(!isWasmInitialized) {
5376 throw new Error("initializeWasm() must be awaited first!");
5378 var new_obj_idx = js_objs.length;
5379 for (var i = 0; i < js_objs.length; i++) {
5380 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5382 js_objs[i] = new WeakRef(impl);
5383 return wasm.TS_LDKFilter_new(i);
5385 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5387 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5388 if(!isWasmInitialized) {
5389 throw new Error("initializeWasm() must be awaited first!");
5391 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5392 // debug statements here
5394 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5396 export function Filter_register_output(this_arg: number, output: number): number {
5397 if(!isWasmInitialized) {
5398 throw new Error("initializeWasm() must be awaited first!");
5400 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5401 return nativeResponseValue;
5404 export class LDKCOption_FilterZ {
5405 protected constructor() {}
5408 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5409 if(!isWasmInitialized) {
5410 throw new Error("initializeWasm() must be awaited first!");
5412 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5413 return nativeResponseValue;
5416 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5417 if(!isWasmInitialized) {
5418 throw new Error("initializeWasm() must be awaited first!");
5420 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5421 return nativeResponseValue;
5423 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5425 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5426 if(!isWasmInitialized) {
5427 throw new Error("initializeWasm() must be awaited first!");
5429 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5430 return nativeResponseValue;
5432 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5434 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5435 if(!isWasmInitialized) {
5436 throw new Error("initializeWasm() must be awaited first!");
5438 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5439 // debug statements here
5442 export interface LDKMessageSendEventsProvider {
5443 get_and_clear_pending_msg_events (): number;
5447 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5448 if(!isWasmInitialized) {
5449 throw new Error("initializeWasm() must be awaited first!");
5451 var new_obj_idx = js_objs.length;
5452 for (var i = 0; i < js_objs.length; i++) {
5453 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5455 js_objs[i] = new WeakRef(impl);
5456 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5458 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5460 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5461 if(!isWasmInitialized) {
5462 throw new Error("initializeWasm() must be awaited first!");
5464 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5465 return nativeResponseValue;
5468 export interface LDKEventHandler {
5469 handle_event (event: number): void;
5473 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5474 if(!isWasmInitialized) {
5475 throw new Error("initializeWasm() must be awaited first!");
5477 var new_obj_idx = js_objs.length;
5478 for (var i = 0; i < js_objs.length; i++) {
5479 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5481 js_objs[i] = new WeakRef(impl);
5482 return wasm.TS_LDKEventHandler_new(i);
5484 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5486 export function EventHandler_handle_event(this_arg: number, event: number): void {
5487 if(!isWasmInitialized) {
5488 throw new Error("initializeWasm() must be awaited first!");
5490 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5491 // debug statements here
5494 export interface LDKEventsProvider {
5495 process_pending_events (handler: number): void;
5499 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5500 if(!isWasmInitialized) {
5501 throw new Error("initializeWasm() must be awaited first!");
5503 var new_obj_idx = js_objs.length;
5504 for (var i = 0; i < js_objs.length; i++) {
5505 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5507 js_objs[i] = new WeakRef(impl);
5508 return wasm.TS_LDKEventsProvider_new(i);
5510 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5512 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5513 if(!isWasmInitialized) {
5514 throw new Error("initializeWasm() must be awaited first!");
5516 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5517 // debug statements here
5520 export interface LDKScore {
5521 channel_penalty_msat (short_channel_id: bigint, source: number, target: number, usage: number): bigint;
5522 payment_path_failed (path: number, short_channel_id: bigint): void;
5523 payment_path_successful (path: number): void;
5528 export function LDKScore_new(impl: LDKScore): number {
5529 if(!isWasmInitialized) {
5530 throw new Error("initializeWasm() must be awaited first!");
5532 var new_obj_idx = js_objs.length;
5533 for (var i = 0; i < js_objs.length; i++) {
5534 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5536 js_objs[i] = new WeakRef(impl);
5537 return wasm.TS_LDKScore_new(i);
5539 // uint64_t Score_channel_penalty_msat LDKScore *NONNULL_PTR this_arg, uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage
5541 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, source: number, target: number, usage: number): bigint {
5542 if(!isWasmInitialized) {
5543 throw new Error("initializeWasm() must be awaited first!");
5545 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5546 return nativeResponseValue;
5548 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5550 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5551 if(!isWasmInitialized) {
5552 throw new Error("initializeWasm() must be awaited first!");
5554 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5555 // debug statements here
5557 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5559 export function Score_payment_path_successful(this_arg: number, path: number): void {
5560 if(!isWasmInitialized) {
5561 throw new Error("initializeWasm() must be awaited first!");
5563 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5564 // debug statements here
5566 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5568 export function Score_write(this_arg: number): number {
5569 if(!isWasmInitialized) {
5570 throw new Error("initializeWasm() must be awaited first!");
5572 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5573 return nativeResponseValue;
5576 export interface LDKPersister {
5577 persist_manager (channel_manager: number): number;
5578 persist_graph (network_graph: number): number;
5579 persist_scorer (scorer: number): number;
5583 export function LDKPersister_new(impl: LDKPersister): number {
5584 if(!isWasmInitialized) {
5585 throw new Error("initializeWasm() must be awaited first!");
5587 var new_obj_idx = js_objs.length;
5588 for (var i = 0; i < js_objs.length; i++) {
5589 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5591 js_objs[i] = new WeakRef(impl);
5592 return wasm.TS_LDKPersister_new(i);
5594 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5596 export function Persister_persist_manager(this_arg: number, channel_manager: number): number {
5597 if(!isWasmInitialized) {
5598 throw new Error("initializeWasm() must be awaited first!");
5600 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5601 return nativeResponseValue;
5603 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5605 export function Persister_persist_graph(this_arg: number, network_graph: number): number {
5606 if(!isWasmInitialized) {
5607 throw new Error("initializeWasm() must be awaited first!");
5609 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5610 return nativeResponseValue;
5612 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5614 export function Persister_persist_scorer(this_arg: number, scorer: number): number {
5615 if(!isWasmInitialized) {
5616 throw new Error("initializeWasm() must be awaited first!");
5618 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5619 return nativeResponseValue;
5622 export interface LDKListen {
5623 filtered_block_connected (header: number, txdata: number, height: number): void;
5624 block_connected (block: number, height: number): void;
5625 block_disconnected (header: number, height: number): void;
5629 export function LDKListen_new(impl: LDKListen): number {
5630 if(!isWasmInitialized) {
5631 throw new Error("initializeWasm() must be awaited first!");
5633 var new_obj_idx = js_objs.length;
5634 for (var i = 0; i < js_objs.length; i++) {
5635 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5637 js_objs[i] = new WeakRef(impl);
5638 return wasm.TS_LDKListen_new(i);
5640 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5642 export function Listen_filtered_block_connected(this_arg: number, header: number, txdata: number, height: number): void {
5643 if(!isWasmInitialized) {
5644 throw new Error("initializeWasm() must be awaited first!");
5646 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5647 // debug statements here
5649 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5651 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5652 if(!isWasmInitialized) {
5653 throw new Error("initializeWasm() must be awaited first!");
5655 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5656 // debug statements here
5658 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5660 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5661 if(!isWasmInitialized) {
5662 throw new Error("initializeWasm() must be awaited first!");
5664 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5665 // debug statements here
5668 export interface LDKConfirm {
5669 transactions_confirmed (header: number, txdata: number, height: number): void;
5670 transaction_unconfirmed (txid: number): void;
5671 best_block_updated (header: number, height: number): void;
5672 get_relevant_txids (): number;
5676 export function LDKConfirm_new(impl: LDKConfirm): number {
5677 if(!isWasmInitialized) {
5678 throw new Error("initializeWasm() must be awaited first!");
5680 var new_obj_idx = js_objs.length;
5681 for (var i = 0; i < js_objs.length; i++) {
5682 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5684 js_objs[i] = new WeakRef(impl);
5685 return wasm.TS_LDKConfirm_new(i);
5687 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5689 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5690 if(!isWasmInitialized) {
5691 throw new Error("initializeWasm() must be awaited first!");
5693 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5694 // debug statements here
5696 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5698 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5699 if(!isWasmInitialized) {
5700 throw new Error("initializeWasm() must be awaited first!");
5702 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5703 // debug statements here
5705 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5707 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5708 if(!isWasmInitialized) {
5709 throw new Error("initializeWasm() must be awaited first!");
5711 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5712 // debug statements here
5714 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5716 export function Confirm_get_relevant_txids(this_arg: number): number {
5717 if(!isWasmInitialized) {
5718 throw new Error("initializeWasm() must be awaited first!");
5720 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5721 return nativeResponseValue;
5724 export interface LDKPersist {
5725 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5726 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5730 export function LDKPersist_new(impl: LDKPersist): number {
5731 if(!isWasmInitialized) {
5732 throw new Error("initializeWasm() must be awaited first!");
5734 var new_obj_idx = js_objs.length;
5735 for (var i = 0; i < js_objs.length; i++) {
5736 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5738 js_objs[i] = new WeakRef(impl);
5739 return wasm.TS_LDKPersist_new(i);
5741 // 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
5743 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5744 if(!isWasmInitialized) {
5745 throw new Error("initializeWasm() must be awaited first!");
5747 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5748 return nativeResponseValue;
5750 // 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
5752 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5753 if(!isWasmInitialized) {
5754 throw new Error("initializeWasm() must be awaited first!");
5756 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5757 return nativeResponseValue;
5760 export interface LDKChannelMessageHandler {
5761 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5762 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5763 handle_funding_created (their_node_id: number, msg: number): void;
5764 handle_funding_signed (their_node_id: number, msg: number): void;
5765 handle_channel_ready (their_node_id: number, msg: number): void;
5766 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5767 handle_closing_signed (their_node_id: number, msg: number): void;
5768 handle_update_add_htlc (their_node_id: number, msg: number): void;
5769 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5770 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5771 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5772 handle_commitment_signed (their_node_id: number, msg: number): void;
5773 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5774 handle_update_fee (their_node_id: number, msg: number): void;
5775 handle_announcement_signatures (their_node_id: number, msg: number): void;
5776 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5777 peer_connected (their_node_id: number, msg: number): void;
5778 handle_channel_reestablish (their_node_id: number, msg: number): void;
5779 handle_channel_update (their_node_id: number, msg: number): void;
5780 handle_error (their_node_id: number, msg: number): void;
5784 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5785 if(!isWasmInitialized) {
5786 throw new Error("initializeWasm() must be awaited first!");
5788 var new_obj_idx = js_objs.length;
5789 for (var i = 0; i < js_objs.length; i++) {
5790 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5792 js_objs[i] = new WeakRef(impl);
5793 return wasm.TS_LDKChannelMessageHandler_new(i);
5795 // 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
5797 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5798 if(!isWasmInitialized) {
5799 throw new Error("initializeWasm() must be awaited first!");
5801 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5802 // debug statements here
5804 // 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
5806 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5807 if(!isWasmInitialized) {
5808 throw new Error("initializeWasm() must be awaited first!");
5810 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
5811 // debug statements here
5813 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5815 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
5816 if(!isWasmInitialized) {
5817 throw new Error("initializeWasm() must be awaited first!");
5819 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
5820 // debug statements here
5822 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5824 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
5825 if(!isWasmInitialized) {
5826 throw new Error("initializeWasm() must be awaited first!");
5828 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
5829 // debug statements here
5831 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
5833 export function ChannelMessageHandler_handle_channel_ready(this_arg: number, their_node_id: number, msg: number): void {
5834 if(!isWasmInitialized) {
5835 throw new Error("initializeWasm() must be awaited first!");
5837 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
5838 // debug statements here
5840 // 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
5842 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5843 if(!isWasmInitialized) {
5844 throw new Error("initializeWasm() must be awaited first!");
5846 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5847 // debug statements here
5849 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5851 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
5852 if(!isWasmInitialized) {
5853 throw new Error("initializeWasm() must be awaited first!");
5855 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
5856 // debug statements here
5858 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5860 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
5861 if(!isWasmInitialized) {
5862 throw new Error("initializeWasm() must be awaited first!");
5864 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
5865 // debug statements here
5867 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5869 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
5870 if(!isWasmInitialized) {
5871 throw new Error("initializeWasm() must be awaited first!");
5873 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
5874 // debug statements here
5876 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5878 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
5879 if(!isWasmInitialized) {
5880 throw new Error("initializeWasm() must be awaited first!");
5882 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
5883 // debug statements here
5885 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5887 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
5888 if(!isWasmInitialized) {
5889 throw new Error("initializeWasm() must be awaited first!");
5891 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5892 // debug statements here
5894 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5896 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5897 if(!isWasmInitialized) {
5898 throw new Error("initializeWasm() must be awaited first!");
5900 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5901 // debug statements here
5903 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5905 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
5906 if(!isWasmInitialized) {
5907 throw new Error("initializeWasm() must be awaited first!");
5909 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
5910 // debug statements here
5912 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5914 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
5915 if(!isWasmInitialized) {
5916 throw new Error("initializeWasm() must be awaited first!");
5918 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
5919 // debug statements here
5921 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
5923 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
5924 if(!isWasmInitialized) {
5925 throw new Error("initializeWasm() must be awaited first!");
5927 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
5928 // debug statements here
5930 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
5932 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
5933 if(!isWasmInitialized) {
5934 throw new Error("initializeWasm() must be awaited first!");
5936 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
5937 // debug statements here
5939 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
5941 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
5942 if(!isWasmInitialized) {
5943 throw new Error("initializeWasm() must be awaited first!");
5945 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
5946 // debug statements here
5948 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
5950 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
5951 if(!isWasmInitialized) {
5952 throw new Error("initializeWasm() must be awaited first!");
5954 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
5955 // debug statements here
5957 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
5959 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
5960 if(!isWasmInitialized) {
5961 throw new Error("initializeWasm() must be awaited first!");
5963 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
5964 // debug statements here
5966 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
5968 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
5969 if(!isWasmInitialized) {
5970 throw new Error("initializeWasm() must be awaited first!");
5972 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
5973 // debug statements here
5976 export interface LDKRoutingMessageHandler {
5977 handle_node_announcement (msg: number): number;
5978 handle_channel_announcement (msg: number): number;
5979 handle_channel_update (msg: number): number;
5980 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
5981 get_next_node_announcements (starting_point: number, batch_amount: number): number;
5982 peer_connected (their_node_id: number, init: number): void;
5983 handle_reply_channel_range (their_node_id: number, msg: number): number;
5984 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
5985 handle_query_channel_range (their_node_id: number, msg: number): number;
5986 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
5990 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 var new_obj_idx = js_objs.length;
5995 for (var i = 0; i < js_objs.length; i++) {
5996 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5998 js_objs[i] = new WeakRef(impl);
5999 return wasm.TS_LDKRoutingMessageHandler_new(i);
6001 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6003 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
6004 if(!isWasmInitialized) {
6005 throw new Error("initializeWasm() must be awaited first!");
6007 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6008 return nativeResponseValue;
6010 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6012 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
6013 if(!isWasmInitialized) {
6014 throw new Error("initializeWasm() must be awaited first!");
6016 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6017 return nativeResponseValue;
6019 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6021 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
6022 if(!isWasmInitialized) {
6023 throw new Error("initializeWasm() must be awaited first!");
6025 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6026 return nativeResponseValue;
6028 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6030 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
6031 if(!isWasmInitialized) {
6032 throw new Error("initializeWasm() must be awaited first!");
6034 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6035 return nativeResponseValue;
6037 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6039 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
6040 if(!isWasmInitialized) {
6041 throw new Error("initializeWasm() must be awaited first!");
6043 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6044 return nativeResponseValue;
6046 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6048 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
6049 if(!isWasmInitialized) {
6050 throw new Error("initializeWasm() must be awaited first!");
6052 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6053 // debug statements here
6055 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6057 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6058 if(!isWasmInitialized) {
6059 throw new Error("initializeWasm() must be awaited first!");
6061 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6062 return nativeResponseValue;
6064 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6066 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
6067 if(!isWasmInitialized) {
6068 throw new Error("initializeWasm() must be awaited first!");
6070 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6071 return nativeResponseValue;
6073 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6075 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6076 if(!isWasmInitialized) {
6077 throw new Error("initializeWasm() must be awaited first!");
6079 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6080 return nativeResponseValue;
6082 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6084 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
6085 if(!isWasmInitialized) {
6086 throw new Error("initializeWasm() must be awaited first!");
6088 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6089 return nativeResponseValue;
6092 export interface LDKCustomMessageReader {
6093 read (message_type: number, buffer: number): number;
6097 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
6098 if(!isWasmInitialized) {
6099 throw new Error("initializeWasm() must be awaited first!");
6101 var new_obj_idx = js_objs.length;
6102 for (var i = 0; i < js_objs.length; i++) {
6103 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6105 js_objs[i] = new WeakRef(impl);
6106 return wasm.TS_LDKCustomMessageReader_new(i);
6108 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6110 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
6111 if(!isWasmInitialized) {
6112 throw new Error("initializeWasm() must be awaited first!");
6114 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6115 return nativeResponseValue;
6118 export interface LDKCustomMessageHandler {
6119 handle_custom_message (msg: number, sender_node_id: number): number;
6120 get_and_clear_pending_msg (): number;
6124 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
6125 if(!isWasmInitialized) {
6126 throw new Error("initializeWasm() must be awaited first!");
6128 var new_obj_idx = js_objs.length;
6129 for (var i = 0; i < js_objs.length; i++) {
6130 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6132 js_objs[i] = new WeakRef(impl);
6133 return wasm.TS_LDKCustomMessageHandler_new(i);
6135 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6137 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
6138 if(!isWasmInitialized) {
6139 throw new Error("initializeWasm() must be awaited first!");
6141 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6142 return nativeResponseValue;
6144 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6146 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
6147 if(!isWasmInitialized) {
6148 throw new Error("initializeWasm() must be awaited first!");
6150 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6151 return nativeResponseValue;
6154 export interface LDKSocketDescriptor {
6155 send_data (data: number, resume_read: boolean): number;
6156 disconnect_socket (): void;
6157 eq (other_arg: number): boolean;
6162 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
6163 if(!isWasmInitialized) {
6164 throw new Error("initializeWasm() must be awaited first!");
6166 var new_obj_idx = js_objs.length;
6167 for (var i = 0; i < js_objs.length; i++) {
6168 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6170 js_objs[i] = new WeakRef(impl);
6171 return wasm.TS_LDKSocketDescriptor_new(i);
6173 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6175 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
6176 if(!isWasmInitialized) {
6177 throw new Error("initializeWasm() must be awaited first!");
6179 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6180 return nativeResponseValue;
6182 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6184 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
6185 if(!isWasmInitialized) {
6186 throw new Error("initializeWasm() must be awaited first!");
6188 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6189 // debug statements here
6191 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6193 export function SocketDescriptor_hash(this_arg: number): bigint {
6194 if(!isWasmInitialized) {
6195 throw new Error("initializeWasm() must be awaited first!");
6197 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6198 return nativeResponseValue;
6201 export class LDKEffectiveCapacity {
6202 protected constructor() {}
6205 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
6206 if(!isWasmInitialized) {
6207 throw new Error("initializeWasm() must be awaited first!");
6209 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6210 return nativeResponseValue;
6213 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
6214 if(!isWasmInitialized) {
6215 throw new Error("initializeWasm() must be awaited first!");
6217 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6218 return nativeResponseValue;
6221 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6222 if(!isWasmInitialized) {
6223 throw new Error("initializeWasm() must be awaited first!");
6225 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6226 return nativeResponseValue;
6229 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6230 if(!isWasmInitialized) {
6231 throw new Error("initializeWasm() must be awaited first!");
6233 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6234 return nativeResponseValue;
6237 export interface LDKLockableScore {
6242 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6243 if(!isWasmInitialized) {
6244 throw new Error("initializeWasm() must be awaited first!");
6246 var new_obj_idx = js_objs.length;
6247 for (var i = 0; i < js_objs.length; i++) {
6248 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6250 js_objs[i] = new WeakRef(impl);
6251 return wasm.TS_LDKLockableScore_new(i);
6253 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6255 export function LockableScore_lock(this_arg: number): number {
6256 if(!isWasmInitialized) {
6257 throw new Error("initializeWasm() must be awaited first!");
6259 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6260 return nativeResponseValue;
6263 export class LDKFallback {
6264 protected constructor() {}
6267 export function LDKFallback_ty_from_ptr(ptr: number): number {
6268 if(!isWasmInitialized) {
6269 throw new Error("initializeWasm() must be awaited first!");
6271 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6272 return nativeResponseValue;
6275 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6276 if(!isWasmInitialized) {
6277 throw new Error("initializeWasm() must be awaited first!");
6279 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6280 return nativeResponseValue;
6283 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6284 if(!isWasmInitialized) {
6285 throw new Error("initializeWasm() must be awaited first!");
6287 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6288 return nativeResponseValue;
6291 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6292 if(!isWasmInitialized) {
6293 throw new Error("initializeWasm() must be awaited first!");
6295 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6296 return nativeResponseValue;
6299 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6300 if(!isWasmInitialized) {
6301 throw new Error("initializeWasm() must be awaited first!");
6303 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6304 return nativeResponseValue;
6307 export interface LDKPayer {
6309 first_hops (): number;
6310 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6311 send_spontaneous_payment (route: number, payment_preimage: number): number;
6312 retry_payment (route: number, payment_id: number): number;
6313 abandon_payment (payment_id: number): void;
6317 export function LDKPayer_new(impl: LDKPayer): number {
6318 if(!isWasmInitialized) {
6319 throw new Error("initializeWasm() must be awaited first!");
6321 var new_obj_idx = js_objs.length;
6322 for (var i = 0; i < js_objs.length; i++) {
6323 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6325 js_objs[i] = new WeakRef(impl);
6326 return wasm.TS_LDKPayer_new(i);
6328 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6330 export function Payer_node_id(this_arg: number): number {
6331 if(!isWasmInitialized) {
6332 throw new Error("initializeWasm() must be awaited first!");
6334 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6335 return nativeResponseValue;
6337 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6339 export function Payer_first_hops(this_arg: number): number {
6340 if(!isWasmInitialized) {
6341 throw new Error("initializeWasm() must be awaited first!");
6343 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6344 return nativeResponseValue;
6346 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6348 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6349 if(!isWasmInitialized) {
6350 throw new Error("initializeWasm() must be awaited first!");
6352 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6353 return nativeResponseValue;
6355 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6357 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6358 if(!isWasmInitialized) {
6359 throw new Error("initializeWasm() must be awaited first!");
6361 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6362 return nativeResponseValue;
6364 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6366 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6367 if(!isWasmInitialized) {
6368 throw new Error("initializeWasm() must be awaited first!");
6370 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6371 return nativeResponseValue;
6373 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6375 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6376 if(!isWasmInitialized) {
6377 throw new Error("initializeWasm() must be awaited first!");
6379 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6380 // debug statements here
6383 export interface LDKRouter {
6384 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6388 export function LDKRouter_new(impl: LDKRouter): number {
6389 if(!isWasmInitialized) {
6390 throw new Error("initializeWasm() must be awaited first!");
6392 var new_obj_idx = js_objs.length;
6393 for (var i = 0; i < js_objs.length; i++) {
6394 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6396 js_objs[i] = new WeakRef(impl);
6397 return wasm.TS_LDKRouter_new(i);
6399 // LDKCResult_RouteLightningErrorZ Router_find_route LDKRouter *NONNULL_PTR this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer
6401 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6402 if(!isWasmInitialized) {
6403 throw new Error("initializeWasm() must be awaited first!");
6405 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6406 return nativeResponseValue;
6409 export class LDKRetry {
6410 protected constructor() {}
6413 export function LDKRetry_ty_from_ptr(ptr: number): number {
6414 if(!isWasmInitialized) {
6415 throw new Error("initializeWasm() must be awaited first!");
6417 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6418 return nativeResponseValue;
6421 export function LDKRetry_Attempts_get_attempts(ptr: number): number {
6422 if(!isWasmInitialized) {
6423 throw new Error("initializeWasm() must be awaited first!");
6425 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6426 return nativeResponseValue;
6428 // struct LDKStr _ldk_get_compiled_version(void);
6430 export function _ldk_get_compiled_version(): number {
6431 if(!isWasmInitialized) {
6432 throw new Error("initializeWasm() must be awaited first!");
6434 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6435 return nativeResponseValue;
6437 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6439 export function _ldk_c_bindings_get_compiled_version(): number {
6440 if(!isWasmInitialized) {
6441 throw new Error("initializeWasm() must be awaited first!");
6443 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6444 return nativeResponseValue;
6446 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6448 export function Bech32Error_clone_ptr(arg: number): number {
6449 if(!isWasmInitialized) {
6450 throw new Error("initializeWasm() must be awaited first!");
6452 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6453 return nativeResponseValue;
6455 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6457 export function Bech32Error_clone(orig: number): number {
6458 if(!isWasmInitialized) {
6459 throw new Error("initializeWasm() must be awaited first!");
6461 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6462 return nativeResponseValue;
6464 // void Bech32Error_free(struct LDKBech32Error o);
6466 export function Bech32Error_free(o: number): void {
6467 if(!isWasmInitialized) {
6468 throw new Error("initializeWasm() must be awaited first!");
6470 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6471 // debug statements here
6473 // void Transaction_free(struct LDKTransaction _res);
6475 export function Transaction_free(_res: number): void {
6476 if(!isWasmInitialized) {
6477 throw new Error("initializeWasm() must be awaited first!");
6479 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6480 // debug statements here
6482 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6484 export function TxOut_new(script_pubkey: number, value: bigint): number {
6485 if(!isWasmInitialized) {
6486 throw new Error("initializeWasm() must be awaited first!");
6488 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6489 return nativeResponseValue;
6491 // void TxOut_free(struct LDKTxOut _res);
6493 export function TxOut_free(_res: number): void {
6494 if(!isWasmInitialized) {
6495 throw new Error("initializeWasm() must be awaited first!");
6497 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6498 // debug statements here
6500 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6502 export function TxOut_clone_ptr(arg: number): number {
6503 if(!isWasmInitialized) {
6504 throw new Error("initializeWasm() must be awaited first!");
6506 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6507 return nativeResponseValue;
6509 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6511 export function TxOut_clone(orig: number): number {
6512 if(!isWasmInitialized) {
6513 throw new Error("initializeWasm() must be awaited first!");
6515 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6516 return nativeResponseValue;
6518 // void Str_free(struct LDKStr _res);
6520 export function Str_free(_res: number): void {
6521 if(!isWasmInitialized) {
6522 throw new Error("initializeWasm() must be awaited first!");
6524 const nativeResponseValue = wasm.TS_Str_free(_res);
6525 // debug statements here
6527 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6529 export function CResult_NoneNoneZ_ok(): number {
6530 if(!isWasmInitialized) {
6531 throw new Error("initializeWasm() must be awaited first!");
6533 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6534 return nativeResponseValue;
6536 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6538 export function CResult_NoneNoneZ_err(): number {
6539 if(!isWasmInitialized) {
6540 throw new Error("initializeWasm() must be awaited first!");
6542 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6543 return nativeResponseValue;
6545 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6547 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6548 if(!isWasmInitialized) {
6549 throw new Error("initializeWasm() must be awaited first!");
6551 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6552 return nativeResponseValue;
6554 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6556 export function CResult_NoneNoneZ_free(_res: number): void {
6557 if(!isWasmInitialized) {
6558 throw new Error("initializeWasm() must be awaited first!");
6560 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6561 // debug statements here
6563 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6565 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6566 if(!isWasmInitialized) {
6567 throw new Error("initializeWasm() must be awaited first!");
6569 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6570 return nativeResponseValue;
6572 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6574 export function CResult_NoneNoneZ_clone(orig: number): number {
6575 if(!isWasmInitialized) {
6576 throw new Error("initializeWasm() must be awaited first!");
6578 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6579 return nativeResponseValue;
6581 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6583 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6584 if(!isWasmInitialized) {
6585 throw new Error("initializeWasm() must be awaited first!");
6587 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6588 return nativeResponseValue;
6590 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6592 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6593 if(!isWasmInitialized) {
6594 throw new Error("initializeWasm() must be awaited first!");
6596 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6597 return nativeResponseValue;
6599 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6601 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6602 if(!isWasmInitialized) {
6603 throw new Error("initializeWasm() must be awaited first!");
6605 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6606 return nativeResponseValue;
6608 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6610 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6611 if(!isWasmInitialized) {
6612 throw new Error("initializeWasm() must be awaited first!");
6614 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6615 // debug statements here
6617 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6619 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6620 if(!isWasmInitialized) {
6621 throw new Error("initializeWasm() must be awaited first!");
6623 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6624 return nativeResponseValue;
6626 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6628 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6629 if(!isWasmInitialized) {
6630 throw new Error("initializeWasm() must be awaited first!");
6632 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6633 return nativeResponseValue;
6635 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6637 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6638 if(!isWasmInitialized) {
6639 throw new Error("initializeWasm() must be awaited first!");
6641 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6642 return nativeResponseValue;
6644 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6646 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6647 if(!isWasmInitialized) {
6648 throw new Error("initializeWasm() must be awaited first!");
6650 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6651 return nativeResponseValue;
6653 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6655 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6656 if(!isWasmInitialized) {
6657 throw new Error("initializeWasm() must be awaited first!");
6659 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6660 return nativeResponseValue;
6662 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6664 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6665 if(!isWasmInitialized) {
6666 throw new Error("initializeWasm() must be awaited first!");
6668 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6669 // debug statements here
6671 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6673 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6674 if(!isWasmInitialized) {
6675 throw new Error("initializeWasm() must be awaited first!");
6677 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6678 return nativeResponseValue;
6680 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6682 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6683 if(!isWasmInitialized) {
6684 throw new Error("initializeWasm() must be awaited first!");
6686 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6687 return nativeResponseValue;
6689 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6691 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6692 if(!isWasmInitialized) {
6693 throw new Error("initializeWasm() must be awaited first!");
6695 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6696 return nativeResponseValue;
6698 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6700 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6701 if(!isWasmInitialized) {
6702 throw new Error("initializeWasm() must be awaited first!");
6704 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6705 return nativeResponseValue;
6707 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6709 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6710 if(!isWasmInitialized) {
6711 throw new Error("initializeWasm() must be awaited first!");
6713 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6714 return nativeResponseValue;
6716 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6718 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6719 if(!isWasmInitialized) {
6720 throw new Error("initializeWasm() must be awaited first!");
6722 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6723 // debug statements here
6725 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6727 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6728 if(!isWasmInitialized) {
6729 throw new Error("initializeWasm() must be awaited first!");
6731 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6732 return nativeResponseValue;
6734 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6736 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6737 if(!isWasmInitialized) {
6738 throw new Error("initializeWasm() must be awaited first!");
6740 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6741 return nativeResponseValue;
6743 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6745 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6746 if(!isWasmInitialized) {
6747 throw new Error("initializeWasm() must be awaited first!");
6749 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6750 return nativeResponseValue;
6752 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6754 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6755 if(!isWasmInitialized) {
6756 throw new Error("initializeWasm() must be awaited first!");
6758 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6759 return nativeResponseValue;
6761 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6763 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6764 if(!isWasmInitialized) {
6765 throw new Error("initializeWasm() must be awaited first!");
6767 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6768 return nativeResponseValue;
6770 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6772 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6773 if(!isWasmInitialized) {
6774 throw new Error("initializeWasm() must be awaited first!");
6776 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6777 // debug statements here
6779 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6781 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6782 if(!isWasmInitialized) {
6783 throw new Error("initializeWasm() must be awaited first!");
6785 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6786 return nativeResponseValue;
6788 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6790 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6791 if(!isWasmInitialized) {
6792 throw new Error("initializeWasm() must be awaited first!");
6794 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6795 return nativeResponseValue;
6797 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6799 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6800 if(!isWasmInitialized) {
6801 throw new Error("initializeWasm() must be awaited first!");
6803 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6804 return nativeResponseValue;
6806 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6808 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6809 if(!isWasmInitialized) {
6810 throw new Error("initializeWasm() must be awaited first!");
6812 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6813 return nativeResponseValue;
6815 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6817 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6818 if(!isWasmInitialized) {
6819 throw new Error("initializeWasm() must be awaited first!");
6821 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6822 return nativeResponseValue;
6824 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6826 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6827 if(!isWasmInitialized) {
6828 throw new Error("initializeWasm() must be awaited first!");
6830 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6831 // debug statements here
6833 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6835 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6836 if(!isWasmInitialized) {
6837 throw new Error("initializeWasm() must be awaited first!");
6839 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6840 return nativeResponseValue;
6842 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6844 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6845 if(!isWasmInitialized) {
6846 throw new Error("initializeWasm() must be awaited first!");
6848 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6849 return nativeResponseValue;
6851 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6853 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6854 if(!isWasmInitialized) {
6855 throw new Error("initializeWasm() must be awaited first!");
6857 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6858 return nativeResponseValue;
6860 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6862 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6863 if(!isWasmInitialized) {
6864 throw new Error("initializeWasm() must be awaited first!");
6866 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6867 return nativeResponseValue;
6869 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6871 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6872 if(!isWasmInitialized) {
6873 throw new Error("initializeWasm() must be awaited first!");
6875 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6876 return nativeResponseValue;
6878 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6880 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6881 if(!isWasmInitialized) {
6882 throw new Error("initializeWasm() must be awaited first!");
6884 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6885 // debug statements here
6887 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6889 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6890 if(!isWasmInitialized) {
6891 throw new Error("initializeWasm() must be awaited first!");
6893 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6894 return nativeResponseValue;
6896 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6898 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6899 if(!isWasmInitialized) {
6900 throw new Error("initializeWasm() must be awaited first!");
6902 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6903 return nativeResponseValue;
6905 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
6907 export function COption_u32Z_some(o: number): number {
6908 if(!isWasmInitialized) {
6909 throw new Error("initializeWasm() must be awaited first!");
6911 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
6912 return nativeResponseValue;
6914 // struct LDKCOption_u32Z COption_u32Z_none(void);
6916 export function COption_u32Z_none(): number {
6917 if(!isWasmInitialized) {
6918 throw new Error("initializeWasm() must be awaited first!");
6920 const nativeResponseValue = wasm.TS_COption_u32Z_none();
6921 return nativeResponseValue;
6923 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
6925 export function COption_u32Z_free(_res: number): void {
6926 if(!isWasmInitialized) {
6927 throw new Error("initializeWasm() must be awaited first!");
6929 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
6930 // debug statements here
6932 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
6934 export function COption_u32Z_clone_ptr(arg: number): number {
6935 if(!isWasmInitialized) {
6936 throw new Error("initializeWasm() must be awaited first!");
6938 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
6939 return nativeResponseValue;
6941 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
6943 export function COption_u32Z_clone(orig: number): number {
6944 if(!isWasmInitialized) {
6945 throw new Error("initializeWasm() must be awaited first!");
6947 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
6948 return nativeResponseValue;
6950 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
6952 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
6953 if(!isWasmInitialized) {
6954 throw new Error("initializeWasm() must be awaited first!");
6956 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
6957 return nativeResponseValue;
6959 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
6961 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
6962 if(!isWasmInitialized) {
6963 throw new Error("initializeWasm() must be awaited first!");
6965 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
6966 return nativeResponseValue;
6968 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
6970 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
6971 if(!isWasmInitialized) {
6972 throw new Error("initializeWasm() must be awaited first!");
6974 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
6975 return nativeResponseValue;
6977 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
6979 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
6980 if(!isWasmInitialized) {
6981 throw new Error("initializeWasm() must be awaited first!");
6983 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
6984 // debug statements here
6986 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
6988 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
6989 if(!isWasmInitialized) {
6990 throw new Error("initializeWasm() must be awaited first!");
6992 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
6993 return nativeResponseValue;
6995 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
6997 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
6998 if(!isWasmInitialized) {
6999 throw new Error("initializeWasm() must be awaited first!");
7001 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7002 return nativeResponseValue;
7004 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7006 export function COption_NoneZ_some(): COption_NoneZ {
7007 if(!isWasmInitialized) {
7008 throw new Error("initializeWasm() must be awaited first!");
7010 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7011 return nativeResponseValue;
7013 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7015 export function COption_NoneZ_none(): COption_NoneZ {
7016 if(!isWasmInitialized) {
7017 throw new Error("initializeWasm() must be awaited first!");
7019 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7020 return nativeResponseValue;
7022 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7024 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7025 if(!isWasmInitialized) {
7026 throw new Error("initializeWasm() must be awaited first!");
7028 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7029 // debug statements here
7031 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7033 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7034 if(!isWasmInitialized) {
7035 throw new Error("initializeWasm() must be awaited first!");
7037 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7038 return nativeResponseValue;
7040 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7042 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7043 if(!isWasmInitialized) {
7044 throw new Error("initializeWasm() must be awaited first!");
7046 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7047 return nativeResponseValue;
7049 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7051 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7052 if(!isWasmInitialized) {
7053 throw new Error("initializeWasm() must be awaited first!");
7055 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7056 return nativeResponseValue;
7058 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7060 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7061 if(!isWasmInitialized) {
7062 throw new Error("initializeWasm() must be awaited first!");
7064 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7065 // debug statements here
7067 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7069 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7070 if(!isWasmInitialized) {
7071 throw new Error("initializeWasm() must be awaited first!");
7073 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7074 return nativeResponseValue;
7076 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7078 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7079 if(!isWasmInitialized) {
7080 throw new Error("initializeWasm() must be awaited first!");
7082 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7083 return nativeResponseValue;
7085 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7087 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7088 if(!isWasmInitialized) {
7089 throw new Error("initializeWasm() must be awaited first!");
7091 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7092 return nativeResponseValue;
7094 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7096 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7097 if(!isWasmInitialized) {
7098 throw new Error("initializeWasm() must be awaited first!");
7100 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7101 return nativeResponseValue;
7103 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7105 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7106 if(!isWasmInitialized) {
7107 throw new Error("initializeWasm() must be awaited first!");
7109 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7110 return nativeResponseValue;
7112 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7114 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7115 if(!isWasmInitialized) {
7116 throw new Error("initializeWasm() must be awaited first!");
7118 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7119 // debug statements here
7121 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7123 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7124 if(!isWasmInitialized) {
7125 throw new Error("initializeWasm() must be awaited first!");
7127 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7128 return nativeResponseValue;
7130 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7132 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7133 if(!isWasmInitialized) {
7134 throw new Error("initializeWasm() must be awaited first!");
7136 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7137 return nativeResponseValue;
7139 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7141 export function CVec_SignatureZ_free(_res: number): void {
7142 if(!isWasmInitialized) {
7143 throw new Error("initializeWasm() must be awaited first!");
7145 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7146 // debug statements here
7148 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7150 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7151 if(!isWasmInitialized) {
7152 throw new Error("initializeWasm() must be awaited first!");
7154 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7155 return nativeResponseValue;
7157 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7159 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
7160 if(!isWasmInitialized) {
7161 throw new Error("initializeWasm() must be awaited first!");
7163 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7164 return nativeResponseValue;
7166 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7168 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7169 if(!isWasmInitialized) {
7170 throw new Error("initializeWasm() must be awaited first!");
7172 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7173 return nativeResponseValue;
7175 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7177 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7178 if(!isWasmInitialized) {
7179 throw new Error("initializeWasm() must be awaited first!");
7181 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7182 // debug statements here
7184 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7186 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7187 if(!isWasmInitialized) {
7188 throw new Error("initializeWasm() must be awaited first!");
7190 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7191 return nativeResponseValue;
7193 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7195 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7196 if(!isWasmInitialized) {
7197 throw new Error("initializeWasm() must be awaited first!");
7199 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7200 return nativeResponseValue;
7202 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7204 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7205 if(!isWasmInitialized) {
7206 throw new Error("initializeWasm() must be awaited first!");
7208 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7209 return nativeResponseValue;
7211 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7213 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7214 if(!isWasmInitialized) {
7215 throw new Error("initializeWasm() must be awaited first!");
7217 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7218 return nativeResponseValue;
7220 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7222 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7223 if(!isWasmInitialized) {
7224 throw new Error("initializeWasm() must be awaited first!");
7226 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7227 return nativeResponseValue;
7229 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7231 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7232 if(!isWasmInitialized) {
7233 throw new Error("initializeWasm() must be awaited first!");
7235 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7236 // debug statements here
7238 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7240 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7241 if(!isWasmInitialized) {
7242 throw new Error("initializeWasm() must be awaited first!");
7244 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7245 return nativeResponseValue;
7247 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7249 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7250 if(!isWasmInitialized) {
7251 throw new Error("initializeWasm() must be awaited first!");
7253 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7254 return nativeResponseValue;
7256 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7258 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7259 if(!isWasmInitialized) {
7260 throw new Error("initializeWasm() must be awaited first!");
7262 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7263 return nativeResponseValue;
7265 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7267 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7268 if(!isWasmInitialized) {
7269 throw new Error("initializeWasm() must be awaited first!");
7271 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7272 return nativeResponseValue;
7274 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7276 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7277 if(!isWasmInitialized) {
7278 throw new Error("initializeWasm() must be awaited first!");
7280 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7281 return nativeResponseValue;
7283 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7285 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7286 if(!isWasmInitialized) {
7287 throw new Error("initializeWasm() must be awaited first!");
7289 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7290 // debug statements here
7292 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7294 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7295 if(!isWasmInitialized) {
7296 throw new Error("initializeWasm() must be awaited first!");
7298 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7299 return nativeResponseValue;
7301 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7303 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7304 if(!isWasmInitialized) {
7305 throw new Error("initializeWasm() must be awaited first!");
7307 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7308 return nativeResponseValue;
7310 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7312 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7313 if(!isWasmInitialized) {
7314 throw new Error("initializeWasm() must be awaited first!");
7316 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7317 return nativeResponseValue;
7319 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7321 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7322 if(!isWasmInitialized) {
7323 throw new Error("initializeWasm() must be awaited first!");
7325 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7326 // debug statements here
7328 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7330 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7331 if(!isWasmInitialized) {
7332 throw new Error("initializeWasm() must be awaited first!");
7334 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7335 return nativeResponseValue;
7337 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7339 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7340 if(!isWasmInitialized) {
7341 throw new Error("initializeWasm() must be awaited first!");
7343 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7344 return nativeResponseValue;
7346 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7348 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7349 if(!isWasmInitialized) {
7350 throw new Error("initializeWasm() must be awaited first!");
7352 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7353 return nativeResponseValue;
7355 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7357 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7358 if(!isWasmInitialized) {
7359 throw new Error("initializeWasm() must be awaited first!");
7361 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7362 return nativeResponseValue;
7364 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7366 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7367 if(!isWasmInitialized) {
7368 throw new Error("initializeWasm() must be awaited first!");
7370 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7371 return nativeResponseValue;
7373 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7375 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7376 if(!isWasmInitialized) {
7377 throw new Error("initializeWasm() must be awaited first!");
7379 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7380 // debug statements here
7382 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7384 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7385 if(!isWasmInitialized) {
7386 throw new Error("initializeWasm() must be awaited first!");
7388 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7389 return nativeResponseValue;
7391 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7393 export function CResult_CVec_SignatureZNoneZ_err(): number {
7394 if(!isWasmInitialized) {
7395 throw new Error("initializeWasm() must be awaited first!");
7397 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7398 return nativeResponseValue;
7400 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7402 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7403 if(!isWasmInitialized) {
7404 throw new Error("initializeWasm() must be awaited first!");
7406 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7407 return nativeResponseValue;
7409 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7411 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7412 if(!isWasmInitialized) {
7413 throw new Error("initializeWasm() must be awaited first!");
7415 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7416 // debug statements here
7418 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7420 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7421 if(!isWasmInitialized) {
7422 throw new Error("initializeWasm() must be awaited first!");
7424 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7425 return nativeResponseValue;
7427 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7429 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7430 if(!isWasmInitialized) {
7431 throw new Error("initializeWasm() must be awaited first!");
7433 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7434 return nativeResponseValue;
7436 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7438 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7439 if(!isWasmInitialized) {
7440 throw new Error("initializeWasm() must be awaited first!");
7442 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7443 return nativeResponseValue;
7445 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7447 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7448 if(!isWasmInitialized) {
7449 throw new Error("initializeWasm() must be awaited first!");
7451 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7452 return nativeResponseValue;
7454 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7456 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7457 if(!isWasmInitialized) {
7458 throw new Error("initializeWasm() must be awaited first!");
7460 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7461 return nativeResponseValue;
7463 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7465 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7466 if(!isWasmInitialized) {
7467 throw new Error("initializeWasm() must be awaited first!");
7469 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7470 // debug statements here
7472 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7474 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7475 if(!isWasmInitialized) {
7476 throw new Error("initializeWasm() must be awaited first!");
7478 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7479 return nativeResponseValue;
7481 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7483 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7484 if(!isWasmInitialized) {
7485 throw new Error("initializeWasm() must be awaited first!");
7487 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7488 return nativeResponseValue;
7490 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7492 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7493 if(!isWasmInitialized) {
7494 throw new Error("initializeWasm() must be awaited first!");
7496 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7497 return nativeResponseValue;
7499 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7501 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7502 if(!isWasmInitialized) {
7503 throw new Error("initializeWasm() must be awaited first!");
7505 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7506 return nativeResponseValue;
7508 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7510 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7511 if(!isWasmInitialized) {
7512 throw new Error("initializeWasm() must be awaited first!");
7514 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7515 return nativeResponseValue;
7517 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7519 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7520 if(!isWasmInitialized) {
7521 throw new Error("initializeWasm() must be awaited first!");
7523 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7524 // debug statements here
7526 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7528 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7529 if(!isWasmInitialized) {
7530 throw new Error("initializeWasm() must be awaited first!");
7532 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7533 return nativeResponseValue;
7535 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7537 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7538 if(!isWasmInitialized) {
7539 throw new Error("initializeWasm() must be awaited first!");
7541 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7542 return nativeResponseValue;
7544 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7546 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7547 if(!isWasmInitialized) {
7548 throw new Error("initializeWasm() must be awaited first!");
7550 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7551 return nativeResponseValue;
7553 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7555 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7556 if(!isWasmInitialized) {
7557 throw new Error("initializeWasm() must be awaited first!");
7559 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7560 return nativeResponseValue;
7562 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7564 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7565 if(!isWasmInitialized) {
7566 throw new Error("initializeWasm() must be awaited first!");
7568 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7569 return nativeResponseValue;
7571 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7573 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7574 if(!isWasmInitialized) {
7575 throw new Error("initializeWasm() must be awaited first!");
7577 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7578 // debug statements here
7580 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7582 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7583 if(!isWasmInitialized) {
7584 throw new Error("initializeWasm() must be awaited first!");
7586 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7587 return nativeResponseValue;
7589 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7591 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7592 if(!isWasmInitialized) {
7593 throw new Error("initializeWasm() must be awaited first!");
7595 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7596 return nativeResponseValue;
7598 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7600 export function CVec_RouteHopZ_free(_res: number): void {
7601 if(!isWasmInitialized) {
7602 throw new Error("initializeWasm() must be awaited first!");
7604 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7605 // debug statements here
7607 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7609 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7610 if(!isWasmInitialized) {
7611 throw new Error("initializeWasm() must be awaited first!");
7613 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7614 // debug statements here
7616 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7618 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7619 if(!isWasmInitialized) {
7620 throw new Error("initializeWasm() must be awaited first!");
7622 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7623 return nativeResponseValue;
7625 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7627 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7628 if(!isWasmInitialized) {
7629 throw new Error("initializeWasm() must be awaited first!");
7631 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7632 return nativeResponseValue;
7634 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7636 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7637 if(!isWasmInitialized) {
7638 throw new Error("initializeWasm() must be awaited first!");
7640 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7641 return nativeResponseValue;
7643 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7645 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7646 if(!isWasmInitialized) {
7647 throw new Error("initializeWasm() must be awaited first!");
7649 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7650 // debug statements here
7652 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7654 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7655 if(!isWasmInitialized) {
7656 throw new Error("initializeWasm() must be awaited first!");
7658 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7659 return nativeResponseValue;
7661 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7663 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7664 if(!isWasmInitialized) {
7665 throw new Error("initializeWasm() must be awaited first!");
7667 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7668 return nativeResponseValue;
7670 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7672 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7673 if(!isWasmInitialized) {
7674 throw new Error("initializeWasm() must be awaited first!");
7676 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7677 return nativeResponseValue;
7679 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7681 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7682 if(!isWasmInitialized) {
7683 throw new Error("initializeWasm() must be awaited first!");
7685 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7686 return nativeResponseValue;
7688 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7690 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7691 if(!isWasmInitialized) {
7692 throw new Error("initializeWasm() must be awaited first!");
7694 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7695 return nativeResponseValue;
7697 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7699 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7700 if(!isWasmInitialized) {
7701 throw new Error("initializeWasm() must be awaited first!");
7703 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7704 // debug statements here
7706 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7708 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7709 if(!isWasmInitialized) {
7710 throw new Error("initializeWasm() must be awaited first!");
7712 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7713 return nativeResponseValue;
7715 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7717 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7718 if(!isWasmInitialized) {
7719 throw new Error("initializeWasm() must be awaited first!");
7721 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7722 return nativeResponseValue;
7724 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7726 export function CVec_RouteHintZ_free(_res: number): void {
7727 if(!isWasmInitialized) {
7728 throw new Error("initializeWasm() must be awaited first!");
7730 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7731 // debug statements here
7733 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7735 export function COption_u64Z_some(o: bigint): number {
7736 if(!isWasmInitialized) {
7737 throw new Error("initializeWasm() must be awaited first!");
7739 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7740 return nativeResponseValue;
7742 // struct LDKCOption_u64Z COption_u64Z_none(void);
7744 export function COption_u64Z_none(): number {
7745 if(!isWasmInitialized) {
7746 throw new Error("initializeWasm() must be awaited first!");
7748 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7749 return nativeResponseValue;
7751 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7753 export function COption_u64Z_free(_res: number): void {
7754 if(!isWasmInitialized) {
7755 throw new Error("initializeWasm() must be awaited first!");
7757 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7758 // debug statements here
7760 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7762 export function COption_u64Z_clone_ptr(arg: number): number {
7763 if(!isWasmInitialized) {
7764 throw new Error("initializeWasm() must be awaited first!");
7766 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7767 return nativeResponseValue;
7769 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7771 export function COption_u64Z_clone(orig: number): number {
7772 if(!isWasmInitialized) {
7773 throw new Error("initializeWasm() must be awaited first!");
7775 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7776 return nativeResponseValue;
7778 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7780 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7781 if(!isWasmInitialized) {
7782 throw new Error("initializeWasm() must be awaited first!");
7784 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7785 return nativeResponseValue;
7787 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7789 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7790 if(!isWasmInitialized) {
7791 throw new Error("initializeWasm() must be awaited first!");
7793 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7794 return nativeResponseValue;
7796 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7798 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7799 if(!isWasmInitialized) {
7800 throw new Error("initializeWasm() must be awaited first!");
7802 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7803 return nativeResponseValue;
7805 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7807 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7808 if(!isWasmInitialized) {
7809 throw new Error("initializeWasm() must be awaited first!");
7811 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7812 // debug statements here
7814 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7816 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7817 if(!isWasmInitialized) {
7818 throw new Error("initializeWasm() must be awaited first!");
7820 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7821 return nativeResponseValue;
7823 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7825 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7826 if(!isWasmInitialized) {
7827 throw new Error("initializeWasm() must be awaited first!");
7829 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7830 return nativeResponseValue;
7832 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7834 export function CVec_RouteHintHopZ_free(_res: number): void {
7835 if(!isWasmInitialized) {
7836 throw new Error("initializeWasm() must be awaited first!");
7838 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7839 // debug statements here
7841 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7843 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7844 if(!isWasmInitialized) {
7845 throw new Error("initializeWasm() must be awaited first!");
7847 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7848 return nativeResponseValue;
7850 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7852 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7853 if(!isWasmInitialized) {
7854 throw new Error("initializeWasm() must be awaited first!");
7856 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7857 return nativeResponseValue;
7859 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7861 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7862 if(!isWasmInitialized) {
7863 throw new Error("initializeWasm() must be awaited first!");
7865 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7866 return nativeResponseValue;
7868 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7870 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7871 if(!isWasmInitialized) {
7872 throw new Error("initializeWasm() must be awaited first!");
7874 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7875 // debug statements here
7877 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7879 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7880 if(!isWasmInitialized) {
7881 throw new Error("initializeWasm() must be awaited first!");
7883 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7884 return nativeResponseValue;
7886 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7888 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7889 if(!isWasmInitialized) {
7890 throw new Error("initializeWasm() must be awaited first!");
7892 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7893 return nativeResponseValue;
7895 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7897 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7898 if(!isWasmInitialized) {
7899 throw new Error("initializeWasm() must be awaited first!");
7901 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7902 return nativeResponseValue;
7904 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7906 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7907 if(!isWasmInitialized) {
7908 throw new Error("initializeWasm() must be awaited first!");
7910 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7911 return nativeResponseValue;
7913 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7915 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7916 if(!isWasmInitialized) {
7917 throw new Error("initializeWasm() must be awaited first!");
7919 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7920 return nativeResponseValue;
7922 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7924 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7925 if(!isWasmInitialized) {
7926 throw new Error("initializeWasm() must be awaited first!");
7928 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7929 // debug statements here
7931 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7933 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7934 if(!isWasmInitialized) {
7935 throw new Error("initializeWasm() must be awaited first!");
7937 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7938 return nativeResponseValue;
7940 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7942 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7943 if(!isWasmInitialized) {
7944 throw new Error("initializeWasm() must be awaited first!");
7946 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7947 return nativeResponseValue;
7949 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7951 export function CVec_ChannelDetailsZ_free(_res: number): void {
7952 if(!isWasmInitialized) {
7953 throw new Error("initializeWasm() must be awaited first!");
7955 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7956 // debug statements here
7958 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7960 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7961 if(!isWasmInitialized) {
7962 throw new Error("initializeWasm() must be awaited first!");
7964 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7965 return nativeResponseValue;
7967 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7969 export function CResult_RouteLightningErrorZ_err(e: number): number {
7970 if(!isWasmInitialized) {
7971 throw new Error("initializeWasm() must be awaited first!");
7973 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7974 return nativeResponseValue;
7976 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7978 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7979 if(!isWasmInitialized) {
7980 throw new Error("initializeWasm() must be awaited first!");
7982 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7983 return nativeResponseValue;
7985 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7987 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7988 if(!isWasmInitialized) {
7989 throw new Error("initializeWasm() must be awaited first!");
7991 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7992 // debug statements here
7994 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7996 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7997 if(!isWasmInitialized) {
7998 throw new Error("initializeWasm() must be awaited first!");
8000 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8001 return nativeResponseValue;
8003 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8005 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
8006 if(!isWasmInitialized) {
8007 throw new Error("initializeWasm() must be awaited first!");
8009 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8010 return nativeResponseValue;
8012 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8014 export function CVec_PublicKeyZ_free(_res: number): void {
8015 if(!isWasmInitialized) {
8016 throw new Error("initializeWasm() must be awaited first!");
8018 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8019 // debug statements here
8021 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8023 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: number): number {
8024 if(!isWasmInitialized) {
8025 throw new Error("initializeWasm() must be awaited first!");
8027 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8028 return nativeResponseValue;
8030 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8032 export function CResult_PaymentPurposeDecodeErrorZ_err(e: number): number {
8033 if(!isWasmInitialized) {
8034 throw new Error("initializeWasm() must be awaited first!");
8036 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8037 return nativeResponseValue;
8039 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8041 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: number): boolean {
8042 if(!isWasmInitialized) {
8043 throw new Error("initializeWasm() must be awaited first!");
8045 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8046 return nativeResponseValue;
8048 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8050 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: number): void {
8051 if(!isWasmInitialized) {
8052 throw new Error("initializeWasm() must be awaited first!");
8054 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8055 // debug statements here
8057 // uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8059 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: number): number {
8060 if(!isWasmInitialized) {
8061 throw new Error("initializeWasm() must be awaited first!");
8063 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8064 return nativeResponseValue;
8066 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8068 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: number): number {
8069 if(!isWasmInitialized) {
8070 throw new Error("initializeWasm() must be awaited first!");
8072 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8073 return nativeResponseValue;
8075 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8077 export function COption_ClosureReasonZ_some(o: number): number {
8078 if(!isWasmInitialized) {
8079 throw new Error("initializeWasm() must be awaited first!");
8081 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8082 return nativeResponseValue;
8084 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8086 export function COption_ClosureReasonZ_none(): number {
8087 if(!isWasmInitialized) {
8088 throw new Error("initializeWasm() must be awaited first!");
8090 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8091 return nativeResponseValue;
8093 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8095 export function COption_ClosureReasonZ_free(_res: number): void {
8096 if(!isWasmInitialized) {
8097 throw new Error("initializeWasm() must be awaited first!");
8099 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8100 // debug statements here
8102 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8104 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8105 if(!isWasmInitialized) {
8106 throw new Error("initializeWasm() must be awaited first!");
8108 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8109 return nativeResponseValue;
8111 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8113 export function COption_ClosureReasonZ_clone(orig: number): number {
8114 if(!isWasmInitialized) {
8115 throw new Error("initializeWasm() must be awaited first!");
8117 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8118 return nativeResponseValue;
8120 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8122 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8123 if(!isWasmInitialized) {
8124 throw new Error("initializeWasm() must be awaited first!");
8126 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8127 return nativeResponseValue;
8129 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8131 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8132 if(!isWasmInitialized) {
8133 throw new Error("initializeWasm() must be awaited first!");
8135 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8136 return nativeResponseValue;
8138 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8140 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8141 if(!isWasmInitialized) {
8142 throw new Error("initializeWasm() must be awaited first!");
8144 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8145 return nativeResponseValue;
8147 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8149 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8150 if(!isWasmInitialized) {
8151 throw new Error("initializeWasm() must be awaited first!");
8153 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8154 // debug statements here
8156 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8158 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8159 if(!isWasmInitialized) {
8160 throw new Error("initializeWasm() must be awaited first!");
8162 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8163 return nativeResponseValue;
8165 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8167 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8168 if(!isWasmInitialized) {
8169 throw new Error("initializeWasm() must be awaited first!");
8171 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8172 return nativeResponseValue;
8174 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8176 export function COption_NetworkUpdateZ_some(o: number): number {
8177 if(!isWasmInitialized) {
8178 throw new Error("initializeWasm() must be awaited first!");
8180 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8181 return nativeResponseValue;
8183 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8185 export function COption_NetworkUpdateZ_none(): number {
8186 if(!isWasmInitialized) {
8187 throw new Error("initializeWasm() must be awaited first!");
8189 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8190 return nativeResponseValue;
8192 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8194 export function COption_NetworkUpdateZ_free(_res: number): void {
8195 if(!isWasmInitialized) {
8196 throw new Error("initializeWasm() must be awaited first!");
8198 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8199 // debug statements here
8201 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8203 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8204 if(!isWasmInitialized) {
8205 throw new Error("initializeWasm() must be awaited first!");
8207 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8208 return nativeResponseValue;
8210 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8212 export function COption_NetworkUpdateZ_clone(orig: number): number {
8213 if(!isWasmInitialized) {
8214 throw new Error("initializeWasm() must be awaited first!");
8216 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8217 return nativeResponseValue;
8219 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8221 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8222 if(!isWasmInitialized) {
8223 throw new Error("initializeWasm() must be awaited first!");
8225 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8226 // debug statements here
8228 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8230 export function COption_EventZ_some(o: number): number {
8231 if(!isWasmInitialized) {
8232 throw new Error("initializeWasm() must be awaited first!");
8234 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8235 return nativeResponseValue;
8237 // struct LDKCOption_EventZ COption_EventZ_none(void);
8239 export function COption_EventZ_none(): number {
8240 if(!isWasmInitialized) {
8241 throw new Error("initializeWasm() must be awaited first!");
8243 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8244 return nativeResponseValue;
8246 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8248 export function COption_EventZ_free(_res: number): void {
8249 if(!isWasmInitialized) {
8250 throw new Error("initializeWasm() must be awaited first!");
8252 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8253 // debug statements here
8255 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8257 export function COption_EventZ_clone_ptr(arg: number): number {
8258 if(!isWasmInitialized) {
8259 throw new Error("initializeWasm() must be awaited first!");
8261 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8262 return nativeResponseValue;
8264 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8266 export function COption_EventZ_clone(orig: number): number {
8267 if(!isWasmInitialized) {
8268 throw new Error("initializeWasm() must be awaited first!");
8270 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8271 return nativeResponseValue;
8273 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8275 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8276 if(!isWasmInitialized) {
8277 throw new Error("initializeWasm() must be awaited first!");
8279 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8280 return nativeResponseValue;
8282 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8284 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8285 if(!isWasmInitialized) {
8286 throw new Error("initializeWasm() must be awaited first!");
8288 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8289 return nativeResponseValue;
8291 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8293 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8294 if(!isWasmInitialized) {
8295 throw new Error("initializeWasm() must be awaited first!");
8297 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8298 return nativeResponseValue;
8300 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8302 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8303 if(!isWasmInitialized) {
8304 throw new Error("initializeWasm() must be awaited first!");
8306 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8307 // debug statements here
8309 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8311 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8312 if(!isWasmInitialized) {
8313 throw new Error("initializeWasm() must be awaited first!");
8315 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8316 return nativeResponseValue;
8318 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8320 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8321 if(!isWasmInitialized) {
8322 throw new Error("initializeWasm() must be awaited first!");
8324 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8325 return nativeResponseValue;
8327 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8329 export function CVec_MessageSendEventZ_free(_res: number): void {
8330 if(!isWasmInitialized) {
8331 throw new Error("initializeWasm() must be awaited first!");
8333 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8334 // debug statements here
8336 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8338 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
8339 if(!isWasmInitialized) {
8340 throw new Error("initializeWasm() must be awaited first!");
8342 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8343 return nativeResponseValue;
8345 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8347 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
8348 if(!isWasmInitialized) {
8349 throw new Error("initializeWasm() must be awaited first!");
8351 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8352 return nativeResponseValue;
8354 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8356 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
8357 if(!isWasmInitialized) {
8358 throw new Error("initializeWasm() must be awaited first!");
8360 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8361 return nativeResponseValue;
8363 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8365 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
8366 if(!isWasmInitialized) {
8367 throw new Error("initializeWasm() must be awaited first!");
8369 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8370 // debug statements here
8372 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8374 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
8375 if(!isWasmInitialized) {
8376 throw new Error("initializeWasm() must be awaited first!");
8378 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8379 return nativeResponseValue;
8381 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8383 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
8384 if(!isWasmInitialized) {
8385 throw new Error("initializeWasm() must be awaited first!");
8387 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8388 return nativeResponseValue;
8390 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8392 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
8393 if(!isWasmInitialized) {
8394 throw new Error("initializeWasm() must be awaited first!");
8396 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8397 return nativeResponseValue;
8399 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8401 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
8402 if(!isWasmInitialized) {
8403 throw new Error("initializeWasm() must be awaited first!");
8405 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8406 return nativeResponseValue;
8408 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8410 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
8411 if(!isWasmInitialized) {
8412 throw new Error("initializeWasm() must be awaited first!");
8414 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8415 return nativeResponseValue;
8417 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8419 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
8420 if(!isWasmInitialized) {
8421 throw new Error("initializeWasm() must be awaited first!");
8423 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8424 // debug statements here
8426 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8428 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8429 if(!isWasmInitialized) {
8430 throw new Error("initializeWasm() must be awaited first!");
8432 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8433 // debug statements here
8435 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8437 export function CVec_TxidZ_free(_res: number): void {
8438 if(!isWasmInitialized) {
8439 throw new Error("initializeWasm() must be awaited first!");
8441 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8442 // debug statements here
8444 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8446 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
8447 if(!isWasmInitialized) {
8448 throw new Error("initializeWasm() must be awaited first!");
8450 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8451 return nativeResponseValue;
8453 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8455 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
8456 if(!isWasmInitialized) {
8457 throw new Error("initializeWasm() must be awaited first!");
8459 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8460 return nativeResponseValue;
8462 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8464 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
8465 if(!isWasmInitialized) {
8466 throw new Error("initializeWasm() must be awaited first!");
8468 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8469 return nativeResponseValue;
8471 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8473 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
8474 if(!isWasmInitialized) {
8475 throw new Error("initializeWasm() must be awaited first!");
8477 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8478 // debug statements here
8480 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8482 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
8483 if(!isWasmInitialized) {
8484 throw new Error("initializeWasm() must be awaited first!");
8486 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8487 return nativeResponseValue;
8489 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8491 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
8492 if(!isWasmInitialized) {
8493 throw new Error("initializeWasm() must be awaited first!");
8495 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8496 return nativeResponseValue;
8498 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8500 export function CVec_MonitorEventZ_free(_res: number): void {
8501 if(!isWasmInitialized) {
8502 throw new Error("initializeWasm() must be awaited first!");
8504 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8505 // debug statements here
8507 // uintptr_t C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR arg);
8509 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg: number): number {
8510 if(!isWasmInitialized) {
8511 throw new Error("initializeWasm() must be awaited first!");
8513 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg);
8514 return nativeResponseValue;
8516 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR orig);
8518 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig: number): number {
8519 if(!isWasmInitialized) {
8520 throw new Error("initializeWasm() must be awaited first!");
8522 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig);
8523 return nativeResponseValue;
8525 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b);
8527 export function C2Tuple_OutPointCVec_MonitorEventZZ_new(a: number, b: number): number {
8528 if(!isWasmInitialized) {
8529 throw new Error("initializeWasm() must be awaited first!");
8531 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_new(a, b);
8532 return nativeResponseValue;
8534 // void C2Tuple_OutPointCVec_MonitorEventZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorEventZZ _res);
8536 export function C2Tuple_OutPointCVec_MonitorEventZZ_free(_res: number): void {
8537 if(!isWasmInitialized) {
8538 throw new Error("initializeWasm() must be awaited first!");
8540 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_free(_res);
8541 // debug statements here
8543 // void CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ _res);
8545 export function CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res: number): void {
8546 if(!isWasmInitialized) {
8547 throw new Error("initializeWasm() must be awaited first!");
8549 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res);
8550 // debug statements here
8552 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8554 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8555 if(!isWasmInitialized) {
8556 throw new Error("initializeWasm() must be awaited first!");
8558 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8559 return nativeResponseValue;
8561 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8563 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8564 if(!isWasmInitialized) {
8565 throw new Error("initializeWasm() must be awaited first!");
8567 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8568 return nativeResponseValue;
8570 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8572 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8573 if(!isWasmInitialized) {
8574 throw new Error("initializeWasm() must be awaited first!");
8576 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8577 // debug statements here
8579 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8581 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8582 if(!isWasmInitialized) {
8583 throw new Error("initializeWasm() must be awaited first!");
8585 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8586 return nativeResponseValue;
8588 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8590 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8591 if(!isWasmInitialized) {
8592 throw new Error("initializeWasm() must be awaited first!");
8594 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8595 return nativeResponseValue;
8597 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8599 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8600 if(!isWasmInitialized) {
8601 throw new Error("initializeWasm() must be awaited first!");
8603 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8604 return nativeResponseValue;
8606 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8608 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8609 if(!isWasmInitialized) {
8610 throw new Error("initializeWasm() must be awaited first!");
8612 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8613 return nativeResponseValue;
8615 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8617 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8618 if(!isWasmInitialized) {
8619 throw new Error("initializeWasm() must be awaited first!");
8621 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8622 return nativeResponseValue;
8624 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8626 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8627 if(!isWasmInitialized) {
8628 throw new Error("initializeWasm() must be awaited first!");
8630 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8631 // debug statements here
8633 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8635 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8636 if(!isWasmInitialized) {
8637 throw new Error("initializeWasm() must be awaited first!");
8639 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8640 return nativeResponseValue;
8642 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8644 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8645 if(!isWasmInitialized) {
8646 throw new Error("initializeWasm() must be awaited first!");
8648 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8649 return nativeResponseValue;
8651 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
8653 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
8654 if(!isWasmInitialized) {
8655 throw new Error("initializeWasm() must be awaited first!");
8657 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
8658 return nativeResponseValue;
8660 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
8662 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
8663 if(!isWasmInitialized) {
8664 throw new Error("initializeWasm() must be awaited first!");
8666 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
8667 return nativeResponseValue;
8669 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
8671 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
8672 if(!isWasmInitialized) {
8673 throw new Error("initializeWasm() must be awaited first!");
8675 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
8676 return nativeResponseValue;
8678 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
8680 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
8681 if(!isWasmInitialized) {
8682 throw new Error("initializeWasm() must be awaited first!");
8684 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
8685 // debug statements here
8687 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8689 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8690 if(!isWasmInitialized) {
8691 throw new Error("initializeWasm() must be awaited first!");
8693 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8694 return nativeResponseValue;
8696 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8698 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8699 if(!isWasmInitialized) {
8700 throw new Error("initializeWasm() must be awaited first!");
8702 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8703 return nativeResponseValue;
8705 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8707 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8708 if(!isWasmInitialized) {
8709 throw new Error("initializeWasm() must be awaited first!");
8711 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8712 return nativeResponseValue;
8714 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8716 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8717 if(!isWasmInitialized) {
8718 throw new Error("initializeWasm() must be awaited first!");
8720 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8721 // debug statements here
8723 // uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
8725 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8726 if(!isWasmInitialized) {
8727 throw new Error("initializeWasm() must be awaited first!");
8729 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
8730 return nativeResponseValue;
8732 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
8734 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: number): number {
8735 if(!isWasmInitialized) {
8736 throw new Error("initializeWasm() must be awaited first!");
8738 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
8739 return nativeResponseValue;
8741 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8743 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8744 if(!isWasmInitialized) {
8745 throw new Error("initializeWasm() must be awaited first!");
8747 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8748 return nativeResponseValue;
8750 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8752 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8753 if(!isWasmInitialized) {
8754 throw new Error("initializeWasm() must be awaited first!");
8756 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8757 return nativeResponseValue;
8759 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8761 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8762 if(!isWasmInitialized) {
8763 throw new Error("initializeWasm() must be awaited first!");
8765 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8766 return nativeResponseValue;
8768 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8770 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8771 if(!isWasmInitialized) {
8772 throw new Error("initializeWasm() must be awaited first!");
8774 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8775 // debug statements here
8777 // uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
8779 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8780 if(!isWasmInitialized) {
8781 throw new Error("initializeWasm() must be awaited first!");
8783 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
8784 return nativeResponseValue;
8786 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
8788 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: number): number {
8789 if(!isWasmInitialized) {
8790 throw new Error("initializeWasm() must be awaited first!");
8792 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
8793 return nativeResponseValue;
8795 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8797 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8798 if(!isWasmInitialized) {
8799 throw new Error("initializeWasm() must be awaited first!");
8801 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8802 return nativeResponseValue;
8804 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8806 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8807 if(!isWasmInitialized) {
8808 throw new Error("initializeWasm() must be awaited first!");
8810 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8811 return nativeResponseValue;
8813 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8815 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8816 if(!isWasmInitialized) {
8817 throw new Error("initializeWasm() must be awaited first!");
8819 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8820 return nativeResponseValue;
8822 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8824 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8825 if(!isWasmInitialized) {
8826 throw new Error("initializeWasm() must be awaited first!");
8828 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8829 // debug statements here
8831 // uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
8833 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8834 if(!isWasmInitialized) {
8835 throw new Error("initializeWasm() must be awaited first!");
8837 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
8838 return nativeResponseValue;
8840 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
8842 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: number): number {
8843 if(!isWasmInitialized) {
8844 throw new Error("initializeWasm() must be awaited first!");
8846 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
8847 return nativeResponseValue;
8849 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8851 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8852 if(!isWasmInitialized) {
8853 throw new Error("initializeWasm() must be awaited first!");
8855 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8856 return nativeResponseValue;
8858 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8860 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8861 if(!isWasmInitialized) {
8862 throw new Error("initializeWasm() must be awaited first!");
8864 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8865 return nativeResponseValue;
8867 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8869 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8870 if(!isWasmInitialized) {
8871 throw new Error("initializeWasm() must be awaited first!");
8873 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8874 return nativeResponseValue;
8876 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8878 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8879 if(!isWasmInitialized) {
8880 throw new Error("initializeWasm() must be awaited first!");
8882 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8883 // debug statements here
8885 // uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
8887 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8888 if(!isWasmInitialized) {
8889 throw new Error("initializeWasm() must be awaited first!");
8891 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
8892 return nativeResponseValue;
8894 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
8896 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: number): number {
8897 if(!isWasmInitialized) {
8898 throw new Error("initializeWasm() must be awaited first!");
8900 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
8901 return nativeResponseValue;
8903 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8905 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8906 if(!isWasmInitialized) {
8907 throw new Error("initializeWasm() must be awaited first!");
8909 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
8910 return nativeResponseValue;
8912 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8914 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
8915 if(!isWasmInitialized) {
8916 throw new Error("initializeWasm() must be awaited first!");
8918 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
8919 return nativeResponseValue;
8921 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
8923 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8924 if(!isWasmInitialized) {
8925 throw new Error("initializeWasm() must be awaited first!");
8927 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
8928 return nativeResponseValue;
8930 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
8932 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
8933 if(!isWasmInitialized) {
8934 throw new Error("initializeWasm() must be awaited first!");
8936 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
8937 // debug statements here
8939 // uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
8941 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8942 if(!isWasmInitialized) {
8943 throw new Error("initializeWasm() must be awaited first!");
8945 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
8946 return nativeResponseValue;
8948 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
8950 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: number): number {
8951 if(!isWasmInitialized) {
8952 throw new Error("initializeWasm() must be awaited first!");
8954 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
8955 return nativeResponseValue;
8957 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
8959 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
8960 if(!isWasmInitialized) {
8961 throw new Error("initializeWasm() must be awaited first!");
8963 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
8964 return nativeResponseValue;
8966 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
8968 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
8969 if(!isWasmInitialized) {
8970 throw new Error("initializeWasm() must be awaited first!");
8972 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
8973 return nativeResponseValue;
8975 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
8977 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
8978 if(!isWasmInitialized) {
8979 throw new Error("initializeWasm() must be awaited first!");
8981 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
8982 return nativeResponseValue;
8984 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
8986 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
8987 if(!isWasmInitialized) {
8988 throw new Error("initializeWasm() must be awaited first!");
8990 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
8991 // debug statements here
8993 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
8995 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
8996 if(!isWasmInitialized) {
8997 throw new Error("initializeWasm() must be awaited first!");
8999 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
9000 return nativeResponseValue;
9002 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9004 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
9005 if(!isWasmInitialized) {
9006 throw new Error("initializeWasm() must be awaited first!");
9008 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9009 return nativeResponseValue;
9011 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9013 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
9014 if(!isWasmInitialized) {
9015 throw new Error("initializeWasm() must be awaited first!");
9017 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9018 return nativeResponseValue;
9020 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9022 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
9023 if(!isWasmInitialized) {
9024 throw new Error("initializeWasm() must be awaited first!");
9026 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9027 return nativeResponseValue;
9029 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9031 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
9032 if(!isWasmInitialized) {
9033 throw new Error("initializeWasm() must be awaited first!");
9035 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9036 return nativeResponseValue;
9038 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9040 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
9041 if(!isWasmInitialized) {
9042 throw new Error("initializeWasm() must be awaited first!");
9044 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9045 // debug statements here
9047 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9049 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
9050 if(!isWasmInitialized) {
9051 throw new Error("initializeWasm() must be awaited first!");
9053 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9054 return nativeResponseValue;
9056 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9058 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
9059 if(!isWasmInitialized) {
9060 throw new Error("initializeWasm() must be awaited first!");
9062 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9063 return nativeResponseValue;
9065 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9067 export function COption_AccessZ_some(o: number): number {
9068 if(!isWasmInitialized) {
9069 throw new Error("initializeWasm() must be awaited first!");
9071 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9072 return nativeResponseValue;
9074 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9076 export function COption_AccessZ_none(): number {
9077 if(!isWasmInitialized) {
9078 throw new Error("initializeWasm() must be awaited first!");
9080 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9081 return nativeResponseValue;
9083 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9085 export function COption_AccessZ_free(_res: number): void {
9086 if(!isWasmInitialized) {
9087 throw new Error("initializeWasm() must be awaited first!");
9089 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9090 // debug statements here
9092 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9094 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
9095 if(!isWasmInitialized) {
9096 throw new Error("initializeWasm() must be awaited first!");
9098 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9099 return nativeResponseValue;
9101 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9103 export function CResult_boolLightningErrorZ_err(e: number): number {
9104 if(!isWasmInitialized) {
9105 throw new Error("initializeWasm() must be awaited first!");
9107 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9108 return nativeResponseValue;
9110 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9112 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
9113 if(!isWasmInitialized) {
9114 throw new Error("initializeWasm() must be awaited first!");
9116 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9117 return nativeResponseValue;
9119 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9121 export function CResult_boolLightningErrorZ_free(_res: number): void {
9122 if(!isWasmInitialized) {
9123 throw new Error("initializeWasm() must be awaited first!");
9125 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9126 // debug statements here
9128 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9130 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
9131 if(!isWasmInitialized) {
9132 throw new Error("initializeWasm() must be awaited first!");
9134 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9135 return nativeResponseValue;
9137 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9139 export function CResult_boolLightningErrorZ_clone(orig: number): number {
9140 if(!isWasmInitialized) {
9141 throw new Error("initializeWasm() must be awaited first!");
9143 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9144 return nativeResponseValue;
9146 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9148 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
9149 if(!isWasmInitialized) {
9150 throw new Error("initializeWasm() must be awaited first!");
9152 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9153 return nativeResponseValue;
9155 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9157 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
9158 if(!isWasmInitialized) {
9159 throw new Error("initializeWasm() must be awaited first!");
9161 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9162 return nativeResponseValue;
9164 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9166 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
9167 if(!isWasmInitialized) {
9168 throw new Error("initializeWasm() must be awaited first!");
9170 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9171 return nativeResponseValue;
9173 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9175 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
9176 if(!isWasmInitialized) {
9177 throw new Error("initializeWasm() must be awaited first!");
9179 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9180 // debug statements here
9182 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9184 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9185 if(!isWasmInitialized) {
9186 throw new Error("initializeWasm() must be awaited first!");
9188 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9189 // debug statements here
9191 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9193 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9194 if(!isWasmInitialized) {
9195 throw new Error("initializeWasm() must be awaited first!");
9197 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9198 // debug statements here
9200 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9202 export function CResult_NoneLightningErrorZ_ok(): number {
9203 if(!isWasmInitialized) {
9204 throw new Error("initializeWasm() must be awaited first!");
9206 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9207 return nativeResponseValue;
9209 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9211 export function CResult_NoneLightningErrorZ_err(e: number): number {
9212 if(!isWasmInitialized) {
9213 throw new Error("initializeWasm() must be awaited first!");
9215 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9216 return nativeResponseValue;
9218 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9220 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
9221 if(!isWasmInitialized) {
9222 throw new Error("initializeWasm() must be awaited first!");
9224 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9225 return nativeResponseValue;
9227 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9229 export function CResult_NoneLightningErrorZ_free(_res: number): void {
9230 if(!isWasmInitialized) {
9231 throw new Error("initializeWasm() must be awaited first!");
9233 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9234 // debug statements here
9236 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9238 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
9239 if(!isWasmInitialized) {
9240 throw new Error("initializeWasm() must be awaited first!");
9242 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9243 return nativeResponseValue;
9245 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9247 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
9248 if(!isWasmInitialized) {
9249 throw new Error("initializeWasm() must be awaited first!");
9251 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9252 return nativeResponseValue;
9254 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9256 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
9257 if(!isWasmInitialized) {
9258 throw new Error("initializeWasm() must be awaited first!");
9260 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9261 return nativeResponseValue;
9263 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9265 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
9266 if(!isWasmInitialized) {
9267 throw new Error("initializeWasm() must be awaited first!");
9269 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9270 return nativeResponseValue;
9272 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9274 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
9275 if(!isWasmInitialized) {
9276 throw new Error("initializeWasm() must be awaited first!");
9278 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9279 return nativeResponseValue;
9281 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9283 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
9284 if(!isWasmInitialized) {
9285 throw new Error("initializeWasm() must be awaited first!");
9287 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9288 // debug statements here
9290 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9292 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
9293 if(!isWasmInitialized) {
9294 throw new Error("initializeWasm() must be awaited first!");
9296 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9297 return nativeResponseValue;
9299 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9301 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
9302 if(!isWasmInitialized) {
9303 throw new Error("initializeWasm() must be awaited first!");
9305 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9306 return nativeResponseValue;
9308 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9310 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
9311 if(!isWasmInitialized) {
9312 throw new Error("initializeWasm() must be awaited first!");
9314 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9315 return nativeResponseValue;
9317 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9319 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
9320 if(!isWasmInitialized) {
9321 throw new Error("initializeWasm() must be awaited first!");
9323 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9324 return nativeResponseValue;
9326 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9328 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
9329 if(!isWasmInitialized) {
9330 throw new Error("initializeWasm() must be awaited first!");
9332 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9333 return nativeResponseValue;
9335 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9337 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
9338 if(!isWasmInitialized) {
9339 throw new Error("initializeWasm() must be awaited first!");
9341 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9342 // debug statements here
9344 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9346 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
9347 if(!isWasmInitialized) {
9348 throw new Error("initializeWasm() must be awaited first!");
9350 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9351 return nativeResponseValue;
9353 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9355 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
9356 if(!isWasmInitialized) {
9357 throw new Error("initializeWasm() must be awaited first!");
9359 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9360 return nativeResponseValue;
9362 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9364 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
9365 if(!isWasmInitialized) {
9366 throw new Error("initializeWasm() must be awaited first!");
9368 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9369 return nativeResponseValue;
9371 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9373 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
9374 if(!isWasmInitialized) {
9375 throw new Error("initializeWasm() must be awaited first!");
9377 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9378 return nativeResponseValue;
9380 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9382 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
9383 if(!isWasmInitialized) {
9384 throw new Error("initializeWasm() must be awaited first!");
9386 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9387 return nativeResponseValue;
9389 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9391 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
9392 if(!isWasmInitialized) {
9393 throw new Error("initializeWasm() must be awaited first!");
9395 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9396 // debug statements here
9398 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9400 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
9401 if(!isWasmInitialized) {
9402 throw new Error("initializeWasm() must be awaited first!");
9404 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9405 return nativeResponseValue;
9407 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9409 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
9410 if(!isWasmInitialized) {
9411 throw new Error("initializeWasm() must be awaited first!");
9413 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9414 return nativeResponseValue;
9416 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9418 export function CVec_NetAddressZ_free(_res: number): void {
9419 if(!isWasmInitialized) {
9420 throw new Error("initializeWasm() must be awaited first!");
9422 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9423 // debug statements here
9425 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9427 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
9428 if(!isWasmInitialized) {
9429 throw new Error("initializeWasm() must be awaited first!");
9431 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9432 return nativeResponseValue;
9434 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9436 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
9437 if(!isWasmInitialized) {
9438 throw new Error("initializeWasm() must be awaited first!");
9440 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9441 return nativeResponseValue;
9443 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9445 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
9446 if(!isWasmInitialized) {
9447 throw new Error("initializeWasm() must be awaited first!");
9449 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9450 return nativeResponseValue;
9452 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9454 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
9455 if(!isWasmInitialized) {
9456 throw new Error("initializeWasm() must be awaited first!");
9458 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9459 // debug statements here
9461 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9463 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
9464 if(!isWasmInitialized) {
9465 throw new Error("initializeWasm() must be awaited first!");
9467 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9468 return nativeResponseValue;
9470 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9472 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
9473 if(!isWasmInitialized) {
9474 throw new Error("initializeWasm() must be awaited first!");
9476 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9477 return nativeResponseValue;
9479 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
9481 export function CVec_u64Z_free(_res: number): void {
9482 if(!isWasmInitialized) {
9483 throw new Error("initializeWasm() must be awaited first!");
9485 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
9486 // debug statements here
9488 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
9490 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
9491 if(!isWasmInitialized) {
9492 throw new Error("initializeWasm() must be awaited first!");
9494 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
9495 return nativeResponseValue;
9497 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
9499 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
9500 if(!isWasmInitialized) {
9501 throw new Error("initializeWasm() must be awaited first!");
9503 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
9504 return nativeResponseValue;
9506 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
9508 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
9509 if(!isWasmInitialized) {
9510 throw new Error("initializeWasm() must be awaited first!");
9512 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
9513 return nativeResponseValue;
9515 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
9517 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
9518 if(!isWasmInitialized) {
9519 throw new Error("initializeWasm() must be awaited first!");
9521 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
9522 // debug statements here
9524 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
9526 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
9527 if(!isWasmInitialized) {
9528 throw new Error("initializeWasm() must be awaited first!");
9530 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
9531 return nativeResponseValue;
9533 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
9535 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
9536 if(!isWasmInitialized) {
9537 throw new Error("initializeWasm() must be awaited first!");
9539 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
9540 return nativeResponseValue;
9542 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
9544 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
9545 if(!isWasmInitialized) {
9546 throw new Error("initializeWasm() must be awaited first!");
9548 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
9549 return nativeResponseValue;
9551 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
9553 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
9554 if(!isWasmInitialized) {
9555 throw new Error("initializeWasm() must be awaited first!");
9557 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
9558 return nativeResponseValue;
9560 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
9562 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
9563 if(!isWasmInitialized) {
9564 throw new Error("initializeWasm() must be awaited first!");
9566 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
9567 return nativeResponseValue;
9569 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
9571 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
9572 if(!isWasmInitialized) {
9573 throw new Error("initializeWasm() must be awaited first!");
9575 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
9576 // debug statements here
9578 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
9580 export function COption_CVec_NetAddressZZ_some(o: number): number {
9581 if(!isWasmInitialized) {
9582 throw new Error("initializeWasm() must be awaited first!");
9584 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
9585 return nativeResponseValue;
9587 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
9589 export function COption_CVec_NetAddressZZ_none(): number {
9590 if(!isWasmInitialized) {
9591 throw new Error("initializeWasm() must be awaited first!");
9593 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
9594 return nativeResponseValue;
9596 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
9598 export function COption_CVec_NetAddressZZ_free(_res: number): void {
9599 if(!isWasmInitialized) {
9600 throw new Error("initializeWasm() must be awaited first!");
9602 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
9603 // debug statements here
9605 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
9607 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
9608 if(!isWasmInitialized) {
9609 throw new Error("initializeWasm() must be awaited first!");
9611 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
9612 return nativeResponseValue;
9614 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
9616 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
9617 if(!isWasmInitialized) {
9618 throw new Error("initializeWasm() must be awaited first!");
9620 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
9621 return nativeResponseValue;
9623 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
9625 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9626 if(!isWasmInitialized) {
9627 throw new Error("initializeWasm() must be awaited first!");
9629 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
9630 return nativeResponseValue;
9632 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9634 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9635 if(!isWasmInitialized) {
9636 throw new Error("initializeWasm() must be awaited first!");
9638 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
9639 return nativeResponseValue;
9641 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9643 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9644 if(!isWasmInitialized) {
9645 throw new Error("initializeWasm() must be awaited first!");
9647 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9648 return nativeResponseValue;
9650 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
9652 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9653 if(!isWasmInitialized) {
9654 throw new Error("initializeWasm() must be awaited first!");
9656 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
9657 // debug statements here
9659 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9661 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9662 if(!isWasmInitialized) {
9663 throw new Error("initializeWasm() must be awaited first!");
9665 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9666 return nativeResponseValue;
9668 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9670 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9671 if(!isWasmInitialized) {
9672 throw new Error("initializeWasm() must be awaited first!");
9674 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9675 return nativeResponseValue;
9677 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
9679 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9680 if(!isWasmInitialized) {
9681 throw new Error("initializeWasm() must be awaited first!");
9683 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
9684 return nativeResponseValue;
9686 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9688 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9689 if(!isWasmInitialized) {
9690 throw new Error("initializeWasm() must be awaited first!");
9692 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
9693 return nativeResponseValue;
9695 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9697 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9698 if(!isWasmInitialized) {
9699 throw new Error("initializeWasm() must be awaited first!");
9701 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9702 return nativeResponseValue;
9704 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
9706 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9707 if(!isWasmInitialized) {
9708 throw new Error("initializeWasm() must be awaited first!");
9710 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
9711 // debug statements here
9713 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9715 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9716 if(!isWasmInitialized) {
9717 throw new Error("initializeWasm() must be awaited first!");
9719 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9720 return nativeResponseValue;
9722 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9724 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9725 if(!isWasmInitialized) {
9726 throw new Error("initializeWasm() must be awaited first!");
9728 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9729 return nativeResponseValue;
9731 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
9733 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
9734 if(!isWasmInitialized) {
9735 throw new Error("initializeWasm() must be awaited first!");
9737 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
9738 return nativeResponseValue;
9740 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9742 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
9743 if(!isWasmInitialized) {
9744 throw new Error("initializeWasm() must be awaited first!");
9746 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
9747 return nativeResponseValue;
9749 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9751 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9752 if(!isWasmInitialized) {
9753 throw new Error("initializeWasm() must be awaited first!");
9755 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
9756 return nativeResponseValue;
9758 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
9760 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
9761 if(!isWasmInitialized) {
9762 throw new Error("initializeWasm() must be awaited first!");
9764 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
9765 // debug statements here
9767 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9769 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9770 if(!isWasmInitialized) {
9771 throw new Error("initializeWasm() must be awaited first!");
9773 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9774 return nativeResponseValue;
9776 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9778 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9779 if(!isWasmInitialized) {
9780 throw new Error("initializeWasm() must be awaited first!");
9782 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
9783 return nativeResponseValue;
9785 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
9787 export function CVec_PaymentPreimageZ_free(_res: number): void {
9788 if(!isWasmInitialized) {
9789 throw new Error("initializeWasm() must be awaited first!");
9791 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
9792 // debug statements here
9794 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
9796 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
9797 if(!isWasmInitialized) {
9798 throw new Error("initializeWasm() must be awaited first!");
9800 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
9801 return nativeResponseValue;
9803 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
9805 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
9806 if(!isWasmInitialized) {
9807 throw new Error("initializeWasm() must be awaited first!");
9809 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
9810 return nativeResponseValue;
9812 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
9814 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
9815 if(!isWasmInitialized) {
9816 throw new Error("initializeWasm() must be awaited first!");
9818 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
9819 return nativeResponseValue;
9821 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
9823 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
9824 if(!isWasmInitialized) {
9825 throw new Error("initializeWasm() must be awaited first!");
9827 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
9828 // debug statements here
9830 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
9832 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
9833 if(!isWasmInitialized) {
9834 throw new Error("initializeWasm() must be awaited first!");
9836 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
9837 return nativeResponseValue;
9839 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
9841 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
9842 if(!isWasmInitialized) {
9843 throw new Error("initializeWasm() must be awaited first!");
9845 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
9846 return nativeResponseValue;
9848 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
9850 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
9851 if(!isWasmInitialized) {
9852 throw new Error("initializeWasm() must be awaited first!");
9854 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
9855 return nativeResponseValue;
9857 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
9859 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
9860 if(!isWasmInitialized) {
9861 throw new Error("initializeWasm() must be awaited first!");
9863 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
9864 // debug statements here
9866 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
9868 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
9869 if(!isWasmInitialized) {
9870 throw new Error("initializeWasm() must be awaited first!");
9872 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
9873 return nativeResponseValue;
9875 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
9877 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
9878 if(!isWasmInitialized) {
9879 throw new Error("initializeWasm() must be awaited first!");
9881 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
9882 return nativeResponseValue;
9884 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
9886 export function CResult_SignatureNoneZ_ok(o: number): number {
9887 if(!isWasmInitialized) {
9888 throw new Error("initializeWasm() must be awaited first!");
9890 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
9891 return nativeResponseValue;
9893 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
9895 export function CResult_SignatureNoneZ_err(): number {
9896 if(!isWasmInitialized) {
9897 throw new Error("initializeWasm() must be awaited first!");
9899 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
9900 return nativeResponseValue;
9902 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
9904 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
9905 if(!isWasmInitialized) {
9906 throw new Error("initializeWasm() must be awaited first!");
9908 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
9909 return nativeResponseValue;
9911 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
9913 export function CResult_SignatureNoneZ_free(_res: number): void {
9914 if(!isWasmInitialized) {
9915 throw new Error("initializeWasm() must be awaited first!");
9917 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
9918 // debug statements here
9920 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
9922 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
9923 if(!isWasmInitialized) {
9924 throw new Error("initializeWasm() must be awaited first!");
9926 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
9927 return nativeResponseValue;
9929 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
9931 export function CResult_SignatureNoneZ_clone(orig: number): number {
9932 if(!isWasmInitialized) {
9933 throw new Error("initializeWasm() must be awaited first!");
9935 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
9936 return nativeResponseValue;
9938 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
9940 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
9941 if(!isWasmInitialized) {
9942 throw new Error("initializeWasm() must be awaited first!");
9944 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
9945 return nativeResponseValue;
9947 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
9949 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
9950 if(!isWasmInitialized) {
9951 throw new Error("initializeWasm() must be awaited first!");
9953 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
9954 return nativeResponseValue;
9956 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
9958 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
9959 if(!isWasmInitialized) {
9960 throw new Error("initializeWasm() must be awaited first!");
9962 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
9963 return nativeResponseValue;
9965 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
9967 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
9968 if(!isWasmInitialized) {
9969 throw new Error("initializeWasm() must be awaited first!");
9971 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
9972 // debug statements here
9974 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
9976 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
9977 if(!isWasmInitialized) {
9978 throw new Error("initializeWasm() must be awaited first!");
9980 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
9981 return nativeResponseValue;
9983 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
9985 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
9986 if(!isWasmInitialized) {
9987 throw new Error("initializeWasm() must be awaited first!");
9989 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
9990 return nativeResponseValue;
9992 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
9994 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
9995 if(!isWasmInitialized) {
9996 throw new Error("initializeWasm() must be awaited first!");
9998 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
9999 return nativeResponseValue;
10001 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10003 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
10004 if(!isWasmInitialized) {
10005 throw new Error("initializeWasm() must be awaited first!");
10007 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10008 // debug statements here
10010 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10012 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
10013 if(!isWasmInitialized) {
10014 throw new Error("initializeWasm() must be awaited first!");
10016 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10017 return nativeResponseValue;
10019 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10021 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
10022 if(!isWasmInitialized) {
10023 throw new Error("initializeWasm() must be awaited first!");
10025 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10026 return nativeResponseValue;
10028 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10030 export function CResult_SecretKeyNoneZ_ok(o: number): number {
10031 if(!isWasmInitialized) {
10032 throw new Error("initializeWasm() must be awaited first!");
10034 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10035 return nativeResponseValue;
10037 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10039 export function CResult_SecretKeyNoneZ_err(): number {
10040 if(!isWasmInitialized) {
10041 throw new Error("initializeWasm() must be awaited first!");
10043 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10044 return nativeResponseValue;
10046 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10048 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
10049 if(!isWasmInitialized) {
10050 throw new Error("initializeWasm() must be awaited first!");
10052 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10053 return nativeResponseValue;
10055 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10057 export function CResult_SecretKeyNoneZ_free(_res: number): void {
10058 if(!isWasmInitialized) {
10059 throw new Error("initializeWasm() must be awaited first!");
10061 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10062 // debug statements here
10064 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10066 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
10067 if(!isWasmInitialized) {
10068 throw new Error("initializeWasm() must be awaited first!");
10070 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10071 return nativeResponseValue;
10073 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10075 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
10076 if(!isWasmInitialized) {
10077 throw new Error("initializeWasm() must be awaited first!");
10079 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10080 return nativeResponseValue;
10082 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10084 export function CResult_SignDecodeErrorZ_ok(o: number): number {
10085 if(!isWasmInitialized) {
10086 throw new Error("initializeWasm() must be awaited first!");
10088 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10089 return nativeResponseValue;
10091 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10093 export function CResult_SignDecodeErrorZ_err(e: number): number {
10094 if(!isWasmInitialized) {
10095 throw new Error("initializeWasm() must be awaited first!");
10097 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10098 return nativeResponseValue;
10100 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10102 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
10103 if(!isWasmInitialized) {
10104 throw new Error("initializeWasm() must be awaited first!");
10106 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10107 return nativeResponseValue;
10109 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10111 export function CResult_SignDecodeErrorZ_free(_res: number): void {
10112 if(!isWasmInitialized) {
10113 throw new Error("initializeWasm() must be awaited first!");
10115 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10116 // debug statements here
10118 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10120 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
10121 if(!isWasmInitialized) {
10122 throw new Error("initializeWasm() must be awaited first!");
10124 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10125 return nativeResponseValue;
10127 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10129 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
10130 if(!isWasmInitialized) {
10131 throw new Error("initializeWasm() must be awaited first!");
10133 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10134 return nativeResponseValue;
10136 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10138 export function CVec_u5Z_free(_res: number): void {
10139 if(!isWasmInitialized) {
10140 throw new Error("initializeWasm() must be awaited first!");
10142 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10143 // debug statements here
10145 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10147 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
10148 if(!isWasmInitialized) {
10149 throw new Error("initializeWasm() must be awaited first!");
10151 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10152 return nativeResponseValue;
10154 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10156 export function CResult_RecoverableSignatureNoneZ_err(): number {
10157 if(!isWasmInitialized) {
10158 throw new Error("initializeWasm() must be awaited first!");
10160 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10161 return nativeResponseValue;
10163 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10165 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
10166 if(!isWasmInitialized) {
10167 throw new Error("initializeWasm() must be awaited first!");
10169 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10170 return nativeResponseValue;
10172 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10174 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
10175 if(!isWasmInitialized) {
10176 throw new Error("initializeWasm() must be awaited first!");
10178 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10179 // debug statements here
10181 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10183 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
10184 if(!isWasmInitialized) {
10185 throw new Error("initializeWasm() must be awaited first!");
10187 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10188 return nativeResponseValue;
10190 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10192 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
10193 if(!isWasmInitialized) {
10194 throw new Error("initializeWasm() must be awaited first!");
10196 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10197 return nativeResponseValue;
10199 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10201 export function CVec_u8Z_free(_res: number): void {
10202 if(!isWasmInitialized) {
10203 throw new Error("initializeWasm() must be awaited first!");
10205 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10206 // debug statements here
10208 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10210 export function CVec_CVec_u8ZZ_free(_res: number): void {
10211 if(!isWasmInitialized) {
10212 throw new Error("initializeWasm() must be awaited first!");
10214 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10215 // debug statements here
10217 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10219 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
10220 if(!isWasmInitialized) {
10221 throw new Error("initializeWasm() must be awaited first!");
10223 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10224 return nativeResponseValue;
10226 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10228 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
10229 if(!isWasmInitialized) {
10230 throw new Error("initializeWasm() must be awaited first!");
10232 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10233 return nativeResponseValue;
10235 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10237 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
10238 if(!isWasmInitialized) {
10239 throw new Error("initializeWasm() must be awaited first!");
10241 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10242 return nativeResponseValue;
10244 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10246 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
10247 if(!isWasmInitialized) {
10248 throw new Error("initializeWasm() must be awaited first!");
10250 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10251 // debug statements here
10253 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10255 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
10256 if(!isWasmInitialized) {
10257 throw new Error("initializeWasm() must be awaited first!");
10259 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10260 return nativeResponseValue;
10262 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10264 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
10265 if(!isWasmInitialized) {
10266 throw new Error("initializeWasm() must be awaited first!");
10268 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10269 return nativeResponseValue;
10271 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10273 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
10274 if(!isWasmInitialized) {
10275 throw new Error("initializeWasm() must be awaited first!");
10277 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10278 return nativeResponseValue;
10280 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10282 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
10283 if(!isWasmInitialized) {
10284 throw new Error("initializeWasm() must be awaited first!");
10286 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10287 return nativeResponseValue;
10289 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10291 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
10292 if(!isWasmInitialized) {
10293 throw new Error("initializeWasm() must be awaited first!");
10295 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10296 return nativeResponseValue;
10298 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10300 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
10301 if(!isWasmInitialized) {
10302 throw new Error("initializeWasm() must be awaited first!");
10304 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10305 // debug statements here
10307 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10309 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
10310 if(!isWasmInitialized) {
10311 throw new Error("initializeWasm() must be awaited first!");
10313 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10314 return nativeResponseValue;
10316 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10318 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
10319 if(!isWasmInitialized) {
10320 throw new Error("initializeWasm() must be awaited first!");
10322 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10323 return nativeResponseValue;
10325 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10327 export function CVec_TxOutZ_free(_res: number): void {
10328 if(!isWasmInitialized) {
10329 throw new Error("initializeWasm() must be awaited first!");
10331 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10332 // debug statements here
10334 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10336 export function CResult_TransactionNoneZ_ok(o: number): number {
10337 if(!isWasmInitialized) {
10338 throw new Error("initializeWasm() must be awaited first!");
10340 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10341 return nativeResponseValue;
10343 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10345 export function CResult_TransactionNoneZ_err(): number {
10346 if(!isWasmInitialized) {
10347 throw new Error("initializeWasm() must be awaited first!");
10349 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10350 return nativeResponseValue;
10352 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10354 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
10355 if(!isWasmInitialized) {
10356 throw new Error("initializeWasm() must be awaited first!");
10358 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10359 return nativeResponseValue;
10361 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10363 export function CResult_TransactionNoneZ_free(_res: number): void {
10364 if(!isWasmInitialized) {
10365 throw new Error("initializeWasm() must be awaited first!");
10367 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10368 // debug statements here
10370 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10372 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
10373 if(!isWasmInitialized) {
10374 throw new Error("initializeWasm() must be awaited first!");
10376 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10377 return nativeResponseValue;
10379 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10381 export function CResult_TransactionNoneZ_clone(orig: number): number {
10382 if(!isWasmInitialized) {
10383 throw new Error("initializeWasm() must be awaited first!");
10385 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10386 return nativeResponseValue;
10388 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10390 export function COption_u16Z_some(o: number): number {
10391 if(!isWasmInitialized) {
10392 throw new Error("initializeWasm() must be awaited first!");
10394 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10395 return nativeResponseValue;
10397 // struct LDKCOption_u16Z COption_u16Z_none(void);
10399 export function COption_u16Z_none(): number {
10400 if(!isWasmInitialized) {
10401 throw new Error("initializeWasm() must be awaited first!");
10403 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10404 return nativeResponseValue;
10406 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10408 export function COption_u16Z_free(_res: number): void {
10409 if(!isWasmInitialized) {
10410 throw new Error("initializeWasm() must be awaited first!");
10412 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10413 // debug statements here
10415 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10417 export function COption_u16Z_clone_ptr(arg: number): number {
10418 if(!isWasmInitialized) {
10419 throw new Error("initializeWasm() must be awaited first!");
10421 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10422 return nativeResponseValue;
10424 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10426 export function COption_u16Z_clone(orig: number): number {
10427 if(!isWasmInitialized) {
10428 throw new Error("initializeWasm() must be awaited first!");
10430 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10431 return nativeResponseValue;
10433 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10435 export function CResult_NoneAPIErrorZ_ok(): number {
10436 if(!isWasmInitialized) {
10437 throw new Error("initializeWasm() must be awaited first!");
10439 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10440 return nativeResponseValue;
10442 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10444 export function CResult_NoneAPIErrorZ_err(e: number): number {
10445 if(!isWasmInitialized) {
10446 throw new Error("initializeWasm() must be awaited first!");
10448 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10449 return nativeResponseValue;
10451 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10453 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
10454 if(!isWasmInitialized) {
10455 throw new Error("initializeWasm() must be awaited first!");
10457 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10458 return nativeResponseValue;
10460 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10462 export function CResult_NoneAPIErrorZ_free(_res: number): void {
10463 if(!isWasmInitialized) {
10464 throw new Error("initializeWasm() must be awaited first!");
10466 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
10467 // debug statements here
10469 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
10471 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
10472 if(!isWasmInitialized) {
10473 throw new Error("initializeWasm() must be awaited first!");
10475 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
10476 return nativeResponseValue;
10478 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
10480 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
10481 if(!isWasmInitialized) {
10482 throw new Error("initializeWasm() must be awaited first!");
10484 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
10485 return nativeResponseValue;
10487 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
10489 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
10490 if(!isWasmInitialized) {
10491 throw new Error("initializeWasm() must be awaited first!");
10493 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
10494 // debug statements here
10496 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
10498 export function CVec_APIErrorZ_free(_res: number): void {
10499 if(!isWasmInitialized) {
10500 throw new Error("initializeWasm() must be awaited first!");
10502 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
10503 // debug statements here
10505 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
10507 export function CResult__u832APIErrorZ_ok(o: number): number {
10508 if(!isWasmInitialized) {
10509 throw new Error("initializeWasm() must be awaited first!");
10511 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
10512 return nativeResponseValue;
10514 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
10516 export function CResult__u832APIErrorZ_err(e: number): number {
10517 if(!isWasmInitialized) {
10518 throw new Error("initializeWasm() must be awaited first!");
10520 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
10521 return nativeResponseValue;
10523 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
10525 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
10526 if(!isWasmInitialized) {
10527 throw new Error("initializeWasm() must be awaited first!");
10529 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
10530 return nativeResponseValue;
10532 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
10534 export function CResult__u832APIErrorZ_free(_res: number): void {
10535 if(!isWasmInitialized) {
10536 throw new Error("initializeWasm() must be awaited first!");
10538 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
10539 // debug statements here
10541 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
10543 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
10544 if(!isWasmInitialized) {
10545 throw new Error("initializeWasm() must be awaited first!");
10547 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
10548 return nativeResponseValue;
10550 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
10552 export function CResult__u832APIErrorZ_clone(orig: number): number {
10553 if(!isWasmInitialized) {
10554 throw new Error("initializeWasm() must be awaited first!");
10556 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
10557 return nativeResponseValue;
10559 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
10561 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
10562 if(!isWasmInitialized) {
10563 throw new Error("initializeWasm() must be awaited first!");
10565 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
10566 return nativeResponseValue;
10568 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10570 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
10571 if(!isWasmInitialized) {
10572 throw new Error("initializeWasm() must be awaited first!");
10574 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
10575 return nativeResponseValue;
10577 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
10579 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
10580 if(!isWasmInitialized) {
10581 throw new Error("initializeWasm() must be awaited first!");
10583 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
10584 return nativeResponseValue;
10586 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
10588 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
10589 if(!isWasmInitialized) {
10590 throw new Error("initializeWasm() must be awaited first!");
10592 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
10593 // debug statements here
10595 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
10597 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
10598 if(!isWasmInitialized) {
10599 throw new Error("initializeWasm() must be awaited first!");
10601 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
10602 return nativeResponseValue;
10604 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
10606 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
10607 if(!isWasmInitialized) {
10608 throw new Error("initializeWasm() must be awaited first!");
10610 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
10611 return nativeResponseValue;
10613 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
10615 export function CResult_NonePaymentSendFailureZ_ok(): number {
10616 if(!isWasmInitialized) {
10617 throw new Error("initializeWasm() must be awaited first!");
10619 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
10620 return nativeResponseValue;
10622 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10624 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
10625 if(!isWasmInitialized) {
10626 throw new Error("initializeWasm() must be awaited first!");
10628 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
10629 return nativeResponseValue;
10631 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
10633 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
10634 if(!isWasmInitialized) {
10635 throw new Error("initializeWasm() must be awaited first!");
10637 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
10638 return nativeResponseValue;
10640 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
10642 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
10643 if(!isWasmInitialized) {
10644 throw new Error("initializeWasm() must be awaited first!");
10646 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
10647 // debug statements here
10649 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
10651 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
10652 if(!isWasmInitialized) {
10653 throw new Error("initializeWasm() must be awaited first!");
10655 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
10656 return nativeResponseValue;
10658 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
10660 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
10661 if(!isWasmInitialized) {
10662 throw new Error("initializeWasm() must be awaited first!");
10664 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
10665 return nativeResponseValue;
10667 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
10669 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
10670 if(!isWasmInitialized) {
10671 throw new Error("initializeWasm() must be awaited first!");
10673 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
10674 return nativeResponseValue;
10676 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
10678 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
10679 if(!isWasmInitialized) {
10680 throw new Error("initializeWasm() must be awaited first!");
10682 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
10683 return nativeResponseValue;
10685 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10687 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
10688 if(!isWasmInitialized) {
10689 throw new Error("initializeWasm() must be awaited first!");
10691 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
10692 return nativeResponseValue;
10694 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
10696 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
10697 if(!isWasmInitialized) {
10698 throw new Error("initializeWasm() must be awaited first!");
10700 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
10701 // debug statements here
10703 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
10705 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
10706 if(!isWasmInitialized) {
10707 throw new Error("initializeWasm() must be awaited first!");
10709 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
10710 return nativeResponseValue;
10712 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10714 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
10715 if(!isWasmInitialized) {
10716 throw new Error("initializeWasm() must be awaited first!");
10718 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
10719 return nativeResponseValue;
10721 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
10723 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
10724 if(!isWasmInitialized) {
10725 throw new Error("initializeWasm() must be awaited first!");
10727 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
10728 return nativeResponseValue;
10730 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
10732 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
10733 if(!isWasmInitialized) {
10734 throw new Error("initializeWasm() must be awaited first!");
10736 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
10737 // debug statements here
10739 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
10741 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
10742 if(!isWasmInitialized) {
10743 throw new Error("initializeWasm() must be awaited first!");
10745 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
10746 return nativeResponseValue;
10748 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
10750 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
10751 if(!isWasmInitialized) {
10752 throw new Error("initializeWasm() must be awaited first!");
10754 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
10755 return nativeResponseValue;
10757 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
10759 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
10760 if(!isWasmInitialized) {
10761 throw new Error("initializeWasm() must be awaited first!");
10763 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
10764 return nativeResponseValue;
10766 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
10768 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
10769 if(!isWasmInitialized) {
10770 throw new Error("initializeWasm() must be awaited first!");
10772 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
10773 return nativeResponseValue;
10775 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10777 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
10778 if(!isWasmInitialized) {
10779 throw new Error("initializeWasm() must be awaited first!");
10781 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
10782 return nativeResponseValue;
10784 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
10786 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
10787 if(!isWasmInitialized) {
10788 throw new Error("initializeWasm() must be awaited first!");
10790 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
10791 // debug statements here
10793 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
10795 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
10796 if(!isWasmInitialized) {
10797 throw new Error("initializeWasm() must be awaited first!");
10799 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
10800 return nativeResponseValue;
10802 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
10804 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
10805 if(!isWasmInitialized) {
10806 throw new Error("initializeWasm() must be awaited first!");
10808 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
10809 return nativeResponseValue;
10811 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
10813 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
10814 if(!isWasmInitialized) {
10815 throw new Error("initializeWasm() must be awaited first!");
10817 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
10818 return nativeResponseValue;
10820 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
10822 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
10823 if(!isWasmInitialized) {
10824 throw new Error("initializeWasm() must be awaited first!");
10826 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
10827 // debug statements here
10829 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
10831 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
10832 if(!isWasmInitialized) {
10833 throw new Error("initializeWasm() must be awaited first!");
10835 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
10836 return nativeResponseValue;
10838 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
10840 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
10841 if(!isWasmInitialized) {
10842 throw new Error("initializeWasm() must be awaited first!");
10844 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
10845 return nativeResponseValue;
10847 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
10849 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
10850 if(!isWasmInitialized) {
10851 throw new Error("initializeWasm() must be awaited first!");
10853 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
10854 return nativeResponseValue;
10856 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
10858 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
10859 if(!isWasmInitialized) {
10860 throw new Error("initializeWasm() must be awaited first!");
10862 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
10863 return nativeResponseValue;
10865 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
10867 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
10868 if(!isWasmInitialized) {
10869 throw new Error("initializeWasm() must be awaited first!");
10871 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
10872 return nativeResponseValue;
10874 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
10876 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
10877 if(!isWasmInitialized) {
10878 throw new Error("initializeWasm() must be awaited first!");
10880 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
10881 // debug statements here
10883 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
10885 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
10886 if(!isWasmInitialized) {
10887 throw new Error("initializeWasm() must be awaited first!");
10889 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
10890 return nativeResponseValue;
10892 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
10894 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
10895 if(!isWasmInitialized) {
10896 throw new Error("initializeWasm() must be awaited first!");
10898 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
10899 return nativeResponseValue;
10901 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
10903 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
10904 if(!isWasmInitialized) {
10905 throw new Error("initializeWasm() must be awaited first!");
10907 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
10908 return nativeResponseValue;
10910 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
10912 export function CResult_PaymentSecretNoneZ_err(): number {
10913 if(!isWasmInitialized) {
10914 throw new Error("initializeWasm() must be awaited first!");
10916 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
10917 return nativeResponseValue;
10919 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
10921 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
10922 if(!isWasmInitialized) {
10923 throw new Error("initializeWasm() must be awaited first!");
10925 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
10926 return nativeResponseValue;
10928 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
10930 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
10931 if(!isWasmInitialized) {
10932 throw new Error("initializeWasm() must be awaited first!");
10934 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
10935 // debug statements here
10937 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
10939 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
10940 if(!isWasmInitialized) {
10941 throw new Error("initializeWasm() must be awaited first!");
10943 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
10944 return nativeResponseValue;
10946 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
10948 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
10949 if(!isWasmInitialized) {
10950 throw new Error("initializeWasm() must be awaited first!");
10952 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
10953 return nativeResponseValue;
10955 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
10957 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
10958 if(!isWasmInitialized) {
10959 throw new Error("initializeWasm() must be awaited first!");
10961 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
10962 return nativeResponseValue;
10964 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
10966 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
10967 if(!isWasmInitialized) {
10968 throw new Error("initializeWasm() must be awaited first!");
10970 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
10971 return nativeResponseValue;
10973 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
10975 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
10976 if(!isWasmInitialized) {
10977 throw new Error("initializeWasm() must be awaited first!");
10979 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
10980 return nativeResponseValue;
10982 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
10984 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
10985 if(!isWasmInitialized) {
10986 throw new Error("initializeWasm() must be awaited first!");
10988 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
10989 // debug statements here
10991 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
10993 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
10994 if(!isWasmInitialized) {
10995 throw new Error("initializeWasm() must be awaited first!");
10997 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
10998 return nativeResponseValue;
11000 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11002 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
11003 if(!isWasmInitialized) {
11004 throw new Error("initializeWasm() must be awaited first!");
11006 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11007 return nativeResponseValue;
11009 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11011 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
11012 if(!isWasmInitialized) {
11013 throw new Error("initializeWasm() must be awaited first!");
11015 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11016 return nativeResponseValue;
11018 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11020 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
11021 if(!isWasmInitialized) {
11022 throw new Error("initializeWasm() must be awaited first!");
11024 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11025 return nativeResponseValue;
11027 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11029 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
11030 if(!isWasmInitialized) {
11031 throw new Error("initializeWasm() must be awaited first!");
11033 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11034 return nativeResponseValue;
11036 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11038 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
11039 if(!isWasmInitialized) {
11040 throw new Error("initializeWasm() must be awaited first!");
11042 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11043 // debug statements here
11045 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11047 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
11048 if(!isWasmInitialized) {
11049 throw new Error("initializeWasm() must be awaited first!");
11051 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11052 return nativeResponseValue;
11054 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11056 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
11057 if(!isWasmInitialized) {
11058 throw new Error("initializeWasm() must be awaited first!");
11060 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11061 return nativeResponseValue;
11063 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11065 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
11066 if(!isWasmInitialized) {
11067 throw new Error("initializeWasm() must be awaited first!");
11069 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11070 return nativeResponseValue;
11072 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11074 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
11075 if(!isWasmInitialized) {
11076 throw new Error("initializeWasm() must be awaited first!");
11078 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11079 return nativeResponseValue;
11081 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11083 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
11084 if(!isWasmInitialized) {
11085 throw new Error("initializeWasm() must be awaited first!");
11087 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11088 return nativeResponseValue;
11090 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11092 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
11093 if(!isWasmInitialized) {
11094 throw new Error("initializeWasm() must be awaited first!");
11096 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11097 // debug statements here
11099 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11101 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
11102 if(!isWasmInitialized) {
11103 throw new Error("initializeWasm() must be awaited first!");
11105 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11106 return nativeResponseValue;
11108 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11110 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
11111 if(!isWasmInitialized) {
11112 throw new Error("initializeWasm() must be awaited first!");
11114 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11115 return nativeResponseValue;
11117 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11119 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
11120 if(!isWasmInitialized) {
11121 throw new Error("initializeWasm() must be awaited first!");
11123 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11124 return nativeResponseValue;
11126 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11128 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
11129 if(!isWasmInitialized) {
11130 throw new Error("initializeWasm() must be awaited first!");
11132 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11133 return nativeResponseValue;
11135 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11137 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
11138 if(!isWasmInitialized) {
11139 throw new Error("initializeWasm() must be awaited first!");
11141 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11142 return nativeResponseValue;
11144 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11146 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
11147 if(!isWasmInitialized) {
11148 throw new Error("initializeWasm() must be awaited first!");
11150 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11151 // debug statements here
11153 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11155 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
11156 if(!isWasmInitialized) {
11157 throw new Error("initializeWasm() must be awaited first!");
11159 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11160 return nativeResponseValue;
11162 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11164 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
11165 if(!isWasmInitialized) {
11166 throw new Error("initializeWasm() must be awaited first!");
11168 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11169 return nativeResponseValue;
11171 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11173 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
11174 if(!isWasmInitialized) {
11175 throw new Error("initializeWasm() must be awaited first!");
11177 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11178 return nativeResponseValue;
11180 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11182 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
11183 if(!isWasmInitialized) {
11184 throw new Error("initializeWasm() must be awaited first!");
11186 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11187 return nativeResponseValue;
11189 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11191 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
11192 if(!isWasmInitialized) {
11193 throw new Error("initializeWasm() must be awaited first!");
11195 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11196 return nativeResponseValue;
11198 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11200 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
11201 if(!isWasmInitialized) {
11202 throw new Error("initializeWasm() must be awaited first!");
11204 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11205 // debug statements here
11207 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11209 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
11210 if(!isWasmInitialized) {
11211 throw new Error("initializeWasm() must be awaited first!");
11213 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11214 return nativeResponseValue;
11216 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11218 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
11219 if(!isWasmInitialized) {
11220 throw new Error("initializeWasm() must be awaited first!");
11222 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11223 return nativeResponseValue;
11225 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11227 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
11228 if(!isWasmInitialized) {
11229 throw new Error("initializeWasm() must be awaited first!");
11231 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11232 return nativeResponseValue;
11234 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11236 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
11237 if(!isWasmInitialized) {
11238 throw new Error("initializeWasm() must be awaited first!");
11240 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11241 return nativeResponseValue;
11243 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11245 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
11246 if(!isWasmInitialized) {
11247 throw new Error("initializeWasm() must be awaited first!");
11249 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11250 return nativeResponseValue;
11252 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11254 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
11255 if(!isWasmInitialized) {
11256 throw new Error("initializeWasm() must be awaited first!");
11258 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11259 // debug statements here
11261 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11263 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
11264 if(!isWasmInitialized) {
11265 throw new Error("initializeWasm() must be awaited first!");
11267 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11268 return nativeResponseValue;
11270 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11272 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
11273 if(!isWasmInitialized) {
11274 throw new Error("initializeWasm() must be awaited first!");
11276 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11277 return nativeResponseValue;
11279 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11281 export function CVec_ChannelMonitorZ_free(_res: number): void {
11282 if(!isWasmInitialized) {
11283 throw new Error("initializeWasm() must be awaited first!");
11285 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11286 // debug statements here
11288 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11290 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
11291 if(!isWasmInitialized) {
11292 throw new Error("initializeWasm() must be awaited first!");
11294 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11295 return nativeResponseValue;
11297 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11299 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
11300 if(!isWasmInitialized) {
11301 throw new Error("initializeWasm() must be awaited first!");
11303 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11304 // debug statements here
11306 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11308 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
11309 if(!isWasmInitialized) {
11310 throw new Error("initializeWasm() must be awaited first!");
11312 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11313 return nativeResponseValue;
11315 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11317 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
11318 if(!isWasmInitialized) {
11319 throw new Error("initializeWasm() must be awaited first!");
11321 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11322 return nativeResponseValue;
11324 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11326 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
11327 if(!isWasmInitialized) {
11328 throw new Error("initializeWasm() must be awaited first!");
11330 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11331 return nativeResponseValue;
11333 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11335 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
11336 if(!isWasmInitialized) {
11337 throw new Error("initializeWasm() must be awaited first!");
11339 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11340 // debug statements here
11342 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11344 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
11345 if(!isWasmInitialized) {
11346 throw new Error("initializeWasm() must be awaited first!");
11348 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11349 return nativeResponseValue;
11351 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11353 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
11354 if(!isWasmInitialized) {
11355 throw new Error("initializeWasm() must be awaited first!");
11357 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11358 return nativeResponseValue;
11360 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11362 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
11363 if(!isWasmInitialized) {
11364 throw new Error("initializeWasm() must be awaited first!");
11366 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11367 return nativeResponseValue;
11369 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11371 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
11372 if(!isWasmInitialized) {
11373 throw new Error("initializeWasm() must be awaited first!");
11375 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11376 // debug statements here
11378 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11380 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
11381 if(!isWasmInitialized) {
11382 throw new Error("initializeWasm() must be awaited first!");
11384 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11385 return nativeResponseValue;
11387 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11389 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
11390 if(!isWasmInitialized) {
11391 throw new Error("initializeWasm() must be awaited first!");
11393 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11394 return nativeResponseValue;
11396 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11398 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
11399 if(!isWasmInitialized) {
11400 throw new Error("initializeWasm() must be awaited first!");
11402 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11403 return nativeResponseValue;
11405 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11407 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
11408 if(!isWasmInitialized) {
11409 throw new Error("initializeWasm() must be awaited first!");
11411 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11412 return nativeResponseValue;
11414 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11416 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
11417 if(!isWasmInitialized) {
11418 throw new Error("initializeWasm() must be awaited first!");
11420 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11421 return nativeResponseValue;
11423 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11425 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
11426 if(!isWasmInitialized) {
11427 throw new Error("initializeWasm() must be awaited first!");
11429 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
11430 // debug statements here
11432 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
11434 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
11435 if(!isWasmInitialized) {
11436 throw new Error("initializeWasm() must be awaited first!");
11438 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
11439 return nativeResponseValue;
11441 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
11443 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
11444 if(!isWasmInitialized) {
11445 throw new Error("initializeWasm() must be awaited first!");
11447 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
11448 return nativeResponseValue;
11450 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
11452 export function COption_TypeZ_some(o: number): number {
11453 if(!isWasmInitialized) {
11454 throw new Error("initializeWasm() must be awaited first!");
11456 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
11457 return nativeResponseValue;
11459 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
11461 export function COption_TypeZ_none(): number {
11462 if(!isWasmInitialized) {
11463 throw new Error("initializeWasm() must be awaited first!");
11465 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
11466 return nativeResponseValue;
11468 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
11470 export function COption_TypeZ_free(_res: number): void {
11471 if(!isWasmInitialized) {
11472 throw new Error("initializeWasm() must be awaited first!");
11474 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
11475 // debug statements here
11477 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
11479 export function COption_TypeZ_clone_ptr(arg: number): number {
11480 if(!isWasmInitialized) {
11481 throw new Error("initializeWasm() must be awaited first!");
11483 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
11484 return nativeResponseValue;
11486 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
11488 export function COption_TypeZ_clone(orig: number): number {
11489 if(!isWasmInitialized) {
11490 throw new Error("initializeWasm() must be awaited first!");
11492 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
11493 return nativeResponseValue;
11495 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
11497 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
11498 if(!isWasmInitialized) {
11499 throw new Error("initializeWasm() must be awaited first!");
11501 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
11502 return nativeResponseValue;
11504 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
11506 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
11507 if(!isWasmInitialized) {
11508 throw new Error("initializeWasm() must be awaited first!");
11510 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
11511 return nativeResponseValue;
11513 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
11515 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
11516 if(!isWasmInitialized) {
11517 throw new Error("initializeWasm() must be awaited first!");
11519 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
11520 return nativeResponseValue;
11522 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
11524 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
11525 if(!isWasmInitialized) {
11526 throw new Error("initializeWasm() must be awaited first!");
11528 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
11529 // debug statements here
11531 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
11533 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
11534 if(!isWasmInitialized) {
11535 throw new Error("initializeWasm() must be awaited first!");
11537 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
11538 return nativeResponseValue;
11540 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
11542 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
11543 if(!isWasmInitialized) {
11544 throw new Error("initializeWasm() must be awaited first!");
11546 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
11547 return nativeResponseValue;
11549 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
11551 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
11552 if(!isWasmInitialized) {
11553 throw new Error("initializeWasm() must be awaited first!");
11555 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
11556 return nativeResponseValue;
11558 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
11560 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
11561 if(!isWasmInitialized) {
11562 throw new Error("initializeWasm() must be awaited first!");
11564 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
11565 return nativeResponseValue;
11567 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
11569 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
11570 if(!isWasmInitialized) {
11571 throw new Error("initializeWasm() must be awaited first!");
11573 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
11574 return nativeResponseValue;
11576 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
11578 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
11579 if(!isWasmInitialized) {
11580 throw new Error("initializeWasm() must be awaited first!");
11582 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
11583 // debug statements here
11585 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
11587 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
11588 if(!isWasmInitialized) {
11589 throw new Error("initializeWasm() must be awaited first!");
11591 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
11592 return nativeResponseValue;
11594 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
11596 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
11597 if(!isWasmInitialized) {
11598 throw new Error("initializeWasm() must be awaited first!");
11600 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
11601 return nativeResponseValue;
11603 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
11605 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
11606 if(!isWasmInitialized) {
11607 throw new Error("initializeWasm() must be awaited first!");
11609 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
11610 return nativeResponseValue;
11612 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
11614 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
11615 if(!isWasmInitialized) {
11616 throw new Error("initializeWasm() must be awaited first!");
11618 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
11619 return nativeResponseValue;
11621 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
11623 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
11624 if(!isWasmInitialized) {
11625 throw new Error("initializeWasm() must be awaited first!");
11627 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
11628 return nativeResponseValue;
11630 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
11632 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
11633 if(!isWasmInitialized) {
11634 throw new Error("initializeWasm() must be awaited first!");
11636 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
11637 // debug statements here
11639 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
11641 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
11642 if(!isWasmInitialized) {
11643 throw new Error("initializeWasm() must be awaited first!");
11645 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
11646 return nativeResponseValue;
11648 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
11650 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
11651 if(!isWasmInitialized) {
11652 throw new Error("initializeWasm() must be awaited first!");
11654 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
11655 return nativeResponseValue;
11657 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
11659 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
11660 if(!isWasmInitialized) {
11661 throw new Error("initializeWasm() must be awaited first!");
11663 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
11664 return nativeResponseValue;
11666 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
11668 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
11669 if(!isWasmInitialized) {
11670 throw new Error("initializeWasm() must be awaited first!");
11672 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
11673 return nativeResponseValue;
11675 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
11677 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
11678 if(!isWasmInitialized) {
11679 throw new Error("initializeWasm() must be awaited first!");
11681 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
11682 return nativeResponseValue;
11684 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
11686 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
11687 if(!isWasmInitialized) {
11688 throw new Error("initializeWasm() must be awaited first!");
11690 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
11691 // debug statements here
11693 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
11695 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
11696 if(!isWasmInitialized) {
11697 throw new Error("initializeWasm() must be awaited first!");
11699 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
11700 return nativeResponseValue;
11702 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
11704 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
11705 if(!isWasmInitialized) {
11706 throw new Error("initializeWasm() must be awaited first!");
11708 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
11709 return nativeResponseValue;
11711 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
11713 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
11714 if(!isWasmInitialized) {
11715 throw new Error("initializeWasm() must be awaited first!");
11717 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
11718 return nativeResponseValue;
11720 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
11722 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
11723 if(!isWasmInitialized) {
11724 throw new Error("initializeWasm() must be awaited first!");
11726 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
11727 return nativeResponseValue;
11729 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
11731 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
11732 if(!isWasmInitialized) {
11733 throw new Error("initializeWasm() must be awaited first!");
11735 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
11736 return nativeResponseValue;
11738 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
11740 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
11741 if(!isWasmInitialized) {
11742 throw new Error("initializeWasm() must be awaited first!");
11744 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
11745 // debug statements here
11747 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
11749 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
11750 if(!isWasmInitialized) {
11751 throw new Error("initializeWasm() must be awaited first!");
11753 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
11754 return nativeResponseValue;
11756 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
11758 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
11759 if(!isWasmInitialized) {
11760 throw new Error("initializeWasm() must be awaited first!");
11762 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
11763 return nativeResponseValue;
11765 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
11767 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
11768 if(!isWasmInitialized) {
11769 throw new Error("initializeWasm() must be awaited first!");
11771 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
11772 return nativeResponseValue;
11774 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
11776 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
11777 if(!isWasmInitialized) {
11778 throw new Error("initializeWasm() must be awaited first!");
11780 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
11781 return nativeResponseValue;
11783 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
11785 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
11786 if(!isWasmInitialized) {
11787 throw new Error("initializeWasm() must be awaited first!");
11789 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
11790 return nativeResponseValue;
11792 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
11794 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
11795 if(!isWasmInitialized) {
11796 throw new Error("initializeWasm() must be awaited first!");
11798 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
11799 // debug statements here
11801 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
11803 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
11804 if(!isWasmInitialized) {
11805 throw new Error("initializeWasm() must be awaited first!");
11807 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
11808 return nativeResponseValue;
11810 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
11812 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
11813 if(!isWasmInitialized) {
11814 throw new Error("initializeWasm() must be awaited first!");
11816 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
11817 return nativeResponseValue;
11819 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
11821 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
11822 if(!isWasmInitialized) {
11823 throw new Error("initializeWasm() must be awaited first!");
11825 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
11826 return nativeResponseValue;
11828 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
11830 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
11831 if(!isWasmInitialized) {
11832 throw new Error("initializeWasm() must be awaited first!");
11834 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
11835 // debug statements here
11837 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
11839 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
11840 if(!isWasmInitialized) {
11841 throw new Error("initializeWasm() must be awaited first!");
11843 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
11844 return nativeResponseValue;
11846 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
11848 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
11849 if(!isWasmInitialized) {
11850 throw new Error("initializeWasm() must be awaited first!");
11852 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
11853 return nativeResponseValue;
11855 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
11857 export function CVec_PrivateRouteZ_free(_res: number): void {
11858 if(!isWasmInitialized) {
11859 throw new Error("initializeWasm() must be awaited first!");
11861 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
11862 // debug statements here
11864 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
11866 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
11867 if(!isWasmInitialized) {
11868 throw new Error("initializeWasm() must be awaited first!");
11870 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
11871 return nativeResponseValue;
11873 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
11875 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
11876 if(!isWasmInitialized) {
11877 throw new Error("initializeWasm() must be awaited first!");
11879 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
11880 return nativeResponseValue;
11882 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
11884 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
11885 if(!isWasmInitialized) {
11886 throw new Error("initializeWasm() must be awaited first!");
11888 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
11889 return nativeResponseValue;
11891 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
11893 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
11894 if(!isWasmInitialized) {
11895 throw new Error("initializeWasm() must be awaited first!");
11897 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
11898 // debug statements here
11900 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
11902 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
11903 if(!isWasmInitialized) {
11904 throw new Error("initializeWasm() must be awaited first!");
11906 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
11907 return nativeResponseValue;
11909 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
11911 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
11912 if(!isWasmInitialized) {
11913 throw new Error("initializeWasm() must be awaited first!");
11915 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
11916 return nativeResponseValue;
11918 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
11920 export function CResult_NoneSemanticErrorZ_ok(): number {
11921 if(!isWasmInitialized) {
11922 throw new Error("initializeWasm() must be awaited first!");
11924 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
11925 return nativeResponseValue;
11927 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
11929 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
11930 if(!isWasmInitialized) {
11931 throw new Error("initializeWasm() must be awaited first!");
11933 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
11934 return nativeResponseValue;
11936 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
11938 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
11939 if(!isWasmInitialized) {
11940 throw new Error("initializeWasm() must be awaited first!");
11942 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
11943 return nativeResponseValue;
11945 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
11947 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
11948 if(!isWasmInitialized) {
11949 throw new Error("initializeWasm() must be awaited first!");
11951 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
11952 // debug statements here
11954 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
11956 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
11957 if(!isWasmInitialized) {
11958 throw new Error("initializeWasm() must be awaited first!");
11960 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
11961 return nativeResponseValue;
11963 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
11965 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
11966 if(!isWasmInitialized) {
11967 throw new Error("initializeWasm() must be awaited first!");
11969 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
11970 return nativeResponseValue;
11972 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
11974 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
11975 if(!isWasmInitialized) {
11976 throw new Error("initializeWasm() must be awaited first!");
11978 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
11979 return nativeResponseValue;
11981 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
11983 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
11984 if(!isWasmInitialized) {
11985 throw new Error("initializeWasm() must be awaited first!");
11987 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
11988 return nativeResponseValue;
11990 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
11992 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
11993 if(!isWasmInitialized) {
11994 throw new Error("initializeWasm() must be awaited first!");
11996 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
11997 return nativeResponseValue;
11999 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
12001 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
12002 if(!isWasmInitialized) {
12003 throw new Error("initializeWasm() must be awaited first!");
12005 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12006 // debug statements here
12008 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12010 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
12011 if(!isWasmInitialized) {
12012 throw new Error("initializeWasm() must be awaited first!");
12014 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12015 return nativeResponseValue;
12017 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12019 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
12020 if(!isWasmInitialized) {
12021 throw new Error("initializeWasm() must be awaited first!");
12023 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12024 return nativeResponseValue;
12026 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12028 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
12029 if(!isWasmInitialized) {
12030 throw new Error("initializeWasm() must be awaited first!");
12032 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12033 return nativeResponseValue;
12035 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12037 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
12038 if(!isWasmInitialized) {
12039 throw new Error("initializeWasm() must be awaited first!");
12041 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12042 return nativeResponseValue;
12044 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12046 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
12047 if(!isWasmInitialized) {
12048 throw new Error("initializeWasm() must be awaited first!");
12050 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12051 return nativeResponseValue;
12053 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12055 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
12056 if(!isWasmInitialized) {
12057 throw new Error("initializeWasm() must be awaited first!");
12059 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12060 // debug statements here
12062 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12064 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
12065 if(!isWasmInitialized) {
12066 throw new Error("initializeWasm() must be awaited first!");
12068 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12069 return nativeResponseValue;
12071 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12073 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
12074 if(!isWasmInitialized) {
12075 throw new Error("initializeWasm() must be awaited first!");
12077 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12078 return nativeResponseValue;
12080 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12082 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
12083 if(!isWasmInitialized) {
12084 throw new Error("initializeWasm() must be awaited first!");
12086 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12087 return nativeResponseValue;
12089 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12091 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
12092 if(!isWasmInitialized) {
12093 throw new Error("initializeWasm() must be awaited first!");
12095 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12096 return nativeResponseValue;
12098 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12100 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
12101 if(!isWasmInitialized) {
12102 throw new Error("initializeWasm() must be awaited first!");
12104 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12105 return nativeResponseValue;
12107 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12109 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
12110 if(!isWasmInitialized) {
12111 throw new Error("initializeWasm() must be awaited first!");
12113 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12114 // debug statements here
12116 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12118 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
12119 if(!isWasmInitialized) {
12120 throw new Error("initializeWasm() must be awaited first!");
12122 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12123 return nativeResponseValue;
12125 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12127 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
12128 if(!isWasmInitialized) {
12129 throw new Error("initializeWasm() must be awaited first!");
12131 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12132 return nativeResponseValue;
12134 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12136 export function CResult_StringErrorZ_ok(o: number): number {
12137 if(!isWasmInitialized) {
12138 throw new Error("initializeWasm() must be awaited first!");
12140 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12141 return nativeResponseValue;
12143 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12145 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
12146 if(!isWasmInitialized) {
12147 throw new Error("initializeWasm() must be awaited first!");
12149 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12150 return nativeResponseValue;
12152 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12154 export function CResult_StringErrorZ_is_ok(o: number): boolean {
12155 if(!isWasmInitialized) {
12156 throw new Error("initializeWasm() must be awaited first!");
12158 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12159 return nativeResponseValue;
12161 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12163 export function CResult_StringErrorZ_free(_res: number): void {
12164 if(!isWasmInitialized) {
12165 throw new Error("initializeWasm() must be awaited first!");
12167 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12168 // debug statements here
12170 // uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12172 export function CResult_StringErrorZ_clone_ptr(arg: number): number {
12173 if(!isWasmInitialized) {
12174 throw new Error("initializeWasm() must be awaited first!");
12176 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12177 return nativeResponseValue;
12179 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12181 export function CResult_StringErrorZ_clone(orig: number): number {
12182 if(!isWasmInitialized) {
12183 throw new Error("initializeWasm() must be awaited first!");
12185 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12186 return nativeResponseValue;
12188 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12190 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
12191 if(!isWasmInitialized) {
12192 throw new Error("initializeWasm() must be awaited first!");
12194 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12195 return nativeResponseValue;
12197 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12199 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
12200 if(!isWasmInitialized) {
12201 throw new Error("initializeWasm() must be awaited first!");
12203 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12204 return nativeResponseValue;
12206 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12208 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
12209 if(!isWasmInitialized) {
12210 throw new Error("initializeWasm() must be awaited first!");
12212 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12213 return nativeResponseValue;
12215 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12217 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
12218 if(!isWasmInitialized) {
12219 throw new Error("initializeWasm() must be awaited first!");
12221 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12222 // debug statements here
12224 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12226 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12227 if(!isWasmInitialized) {
12228 throw new Error("initializeWasm() must be awaited first!");
12230 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12231 return nativeResponseValue;
12233 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12235 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
12236 if(!isWasmInitialized) {
12237 throw new Error("initializeWasm() must be awaited first!");
12239 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12240 return nativeResponseValue;
12242 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12244 export function COption_MonitorEventZ_some(o: number): number {
12245 if(!isWasmInitialized) {
12246 throw new Error("initializeWasm() must be awaited first!");
12248 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12249 return nativeResponseValue;
12251 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12253 export function COption_MonitorEventZ_none(): number {
12254 if(!isWasmInitialized) {
12255 throw new Error("initializeWasm() must be awaited first!");
12257 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12258 return nativeResponseValue;
12260 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12262 export function COption_MonitorEventZ_free(_res: number): void {
12263 if(!isWasmInitialized) {
12264 throw new Error("initializeWasm() must be awaited first!");
12266 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12267 // debug statements here
12269 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12271 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
12272 if(!isWasmInitialized) {
12273 throw new Error("initializeWasm() must be awaited first!");
12275 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12276 return nativeResponseValue;
12278 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12280 export function COption_MonitorEventZ_clone(orig: number): number {
12281 if(!isWasmInitialized) {
12282 throw new Error("initializeWasm() must be awaited first!");
12284 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12285 return nativeResponseValue;
12287 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12289 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
12290 if(!isWasmInitialized) {
12291 throw new Error("initializeWasm() must be awaited first!");
12293 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12294 return nativeResponseValue;
12296 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12298 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
12299 if(!isWasmInitialized) {
12300 throw new Error("initializeWasm() must be awaited first!");
12302 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12303 return nativeResponseValue;
12305 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12307 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
12308 if(!isWasmInitialized) {
12309 throw new Error("initializeWasm() must be awaited first!");
12311 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12312 return nativeResponseValue;
12314 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12316 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
12317 if(!isWasmInitialized) {
12318 throw new Error("initializeWasm() must be awaited first!");
12320 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12321 // debug statements here
12323 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12325 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
12326 if(!isWasmInitialized) {
12327 throw new Error("initializeWasm() must be awaited first!");
12329 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12330 return nativeResponseValue;
12332 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12334 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
12335 if(!isWasmInitialized) {
12336 throw new Error("initializeWasm() must be awaited first!");
12338 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12339 return nativeResponseValue;
12341 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12343 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
12344 if(!isWasmInitialized) {
12345 throw new Error("initializeWasm() must be awaited first!");
12347 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12348 return nativeResponseValue;
12350 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12352 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
12353 if(!isWasmInitialized) {
12354 throw new Error("initializeWasm() must be awaited first!");
12356 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12357 return nativeResponseValue;
12359 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12361 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
12362 if(!isWasmInitialized) {
12363 throw new Error("initializeWasm() must be awaited first!");
12365 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12366 return nativeResponseValue;
12368 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12370 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
12371 if(!isWasmInitialized) {
12372 throw new Error("initializeWasm() must be awaited first!");
12374 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12375 // debug statements here
12377 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12379 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12380 if(!isWasmInitialized) {
12381 throw new Error("initializeWasm() must be awaited first!");
12383 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12384 return nativeResponseValue;
12386 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12388 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
12389 if(!isWasmInitialized) {
12390 throw new Error("initializeWasm() must be awaited first!");
12392 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12393 return nativeResponseValue;
12395 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12397 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
12398 if(!isWasmInitialized) {
12399 throw new Error("initializeWasm() must be awaited first!");
12401 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12402 return nativeResponseValue;
12404 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12406 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
12407 if(!isWasmInitialized) {
12408 throw new Error("initializeWasm() must be awaited first!");
12410 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12411 return nativeResponseValue;
12413 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12415 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
12416 if(!isWasmInitialized) {
12417 throw new Error("initializeWasm() must be awaited first!");
12419 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12420 return nativeResponseValue;
12422 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12424 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
12425 if(!isWasmInitialized) {
12426 throw new Error("initializeWasm() must be awaited first!");
12428 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
12429 // debug statements here
12431 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
12433 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
12434 if(!isWasmInitialized) {
12435 throw new Error("initializeWasm() must be awaited first!");
12437 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
12438 return nativeResponseValue;
12440 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
12442 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
12443 if(!isWasmInitialized) {
12444 throw new Error("initializeWasm() must be awaited first!");
12446 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
12447 return nativeResponseValue;
12449 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
12451 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
12452 if(!isWasmInitialized) {
12453 throw new Error("initializeWasm() must be awaited first!");
12455 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
12456 return nativeResponseValue;
12458 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
12460 export function C2Tuple_u32ScriptZ_free(_res: number): void {
12461 if(!isWasmInitialized) {
12462 throw new Error("initializeWasm() must be awaited first!");
12464 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
12465 // debug statements here
12467 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
12469 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
12470 if(!isWasmInitialized) {
12471 throw new Error("initializeWasm() must be awaited first!");
12473 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
12474 // debug statements here
12476 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
12478 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
12479 if(!isWasmInitialized) {
12480 throw new Error("initializeWasm() must be awaited first!");
12482 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
12483 return nativeResponseValue;
12485 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
12487 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
12488 if(!isWasmInitialized) {
12489 throw new Error("initializeWasm() must be awaited first!");
12491 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
12492 return nativeResponseValue;
12494 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
12496 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
12497 if(!isWasmInitialized) {
12498 throw new Error("initializeWasm() must be awaited first!");
12500 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
12501 return nativeResponseValue;
12503 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
12505 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
12506 if(!isWasmInitialized) {
12507 throw new Error("initializeWasm() must be awaited first!");
12509 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
12510 // debug statements here
12512 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
12514 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
12515 if(!isWasmInitialized) {
12516 throw new Error("initializeWasm() must be awaited first!");
12518 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
12519 // debug statements here
12521 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
12523 export function CVec_EventZ_free(_res: number): void {
12524 if(!isWasmInitialized) {
12525 throw new Error("initializeWasm() must be awaited first!");
12527 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
12528 // debug statements here
12530 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
12532 export function CVec_TransactionZ_free(_res: number): void {
12533 if(!isWasmInitialized) {
12534 throw new Error("initializeWasm() must be awaited first!");
12536 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
12537 // debug statements here
12539 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
12541 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
12542 if(!isWasmInitialized) {
12543 throw new Error("initializeWasm() must be awaited first!");
12545 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
12546 return nativeResponseValue;
12548 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
12550 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
12551 if(!isWasmInitialized) {
12552 throw new Error("initializeWasm() must be awaited first!");
12554 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
12555 return nativeResponseValue;
12557 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
12559 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
12560 if(!isWasmInitialized) {
12561 throw new Error("initializeWasm() must be awaited first!");
12563 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
12564 return nativeResponseValue;
12566 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
12568 export function C2Tuple_u32TxOutZ_free(_res: number): void {
12569 if(!isWasmInitialized) {
12570 throw new Error("initializeWasm() must be awaited first!");
12572 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
12573 // debug statements here
12575 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
12577 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
12578 if(!isWasmInitialized) {
12579 throw new Error("initializeWasm() must be awaited first!");
12581 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
12582 // debug statements here
12584 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
12586 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
12587 if(!isWasmInitialized) {
12588 throw new Error("initializeWasm() must be awaited first!");
12590 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
12591 return nativeResponseValue;
12593 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
12595 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
12596 if(!isWasmInitialized) {
12597 throw new Error("initializeWasm() must be awaited first!");
12599 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
12600 return nativeResponseValue;
12602 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
12604 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
12605 if(!isWasmInitialized) {
12606 throw new Error("initializeWasm() must be awaited first!");
12608 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
12609 return nativeResponseValue;
12611 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
12613 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
12614 if(!isWasmInitialized) {
12615 throw new Error("initializeWasm() must be awaited first!");
12617 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
12618 // debug statements here
12620 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
12622 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
12623 if(!isWasmInitialized) {
12624 throw new Error("initializeWasm() must be awaited first!");
12626 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
12627 // debug statements here
12629 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
12631 export function CVec_BalanceZ_free(_res: number): void {
12632 if(!isWasmInitialized) {
12633 throw new Error("initializeWasm() must be awaited first!");
12635 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
12636 // debug statements here
12638 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
12640 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
12641 if(!isWasmInitialized) {
12642 throw new Error("initializeWasm() must be awaited first!");
12644 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
12645 return nativeResponseValue;
12647 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
12649 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
12650 if(!isWasmInitialized) {
12651 throw new Error("initializeWasm() must be awaited first!");
12653 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
12654 return nativeResponseValue;
12656 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
12658 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
12659 if(!isWasmInitialized) {
12660 throw new Error("initializeWasm() must be awaited first!");
12662 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
12663 return nativeResponseValue;
12665 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
12667 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
12668 if(!isWasmInitialized) {
12669 throw new Error("initializeWasm() must be awaited first!");
12671 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
12672 // debug statements here
12674 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
12676 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
12677 if(!isWasmInitialized) {
12678 throw new Error("initializeWasm() must be awaited first!");
12680 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
12681 return nativeResponseValue;
12683 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
12685 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
12686 if(!isWasmInitialized) {
12687 throw new Error("initializeWasm() must be awaited first!");
12689 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
12690 return nativeResponseValue;
12692 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
12694 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
12695 if(!isWasmInitialized) {
12696 throw new Error("initializeWasm() must be awaited first!");
12698 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
12699 return nativeResponseValue;
12701 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
12703 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
12704 if(!isWasmInitialized) {
12705 throw new Error("initializeWasm() must be awaited first!");
12707 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
12708 // debug statements here
12710 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
12712 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
12713 if(!isWasmInitialized) {
12714 throw new Error("initializeWasm() must be awaited first!");
12716 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
12717 return nativeResponseValue;
12719 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
12721 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
12722 if(!isWasmInitialized) {
12723 throw new Error("initializeWasm() must be awaited first!");
12725 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
12726 return nativeResponseValue;
12728 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
12730 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
12731 if(!isWasmInitialized) {
12732 throw new Error("initializeWasm() must be awaited first!");
12734 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
12735 return nativeResponseValue;
12737 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
12739 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
12740 if(!isWasmInitialized) {
12741 throw new Error("initializeWasm() must be awaited first!");
12743 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
12744 return nativeResponseValue;
12746 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
12748 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
12749 if(!isWasmInitialized) {
12750 throw new Error("initializeWasm() must be awaited first!");
12752 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
12753 return nativeResponseValue;
12755 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
12757 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
12758 if(!isWasmInitialized) {
12759 throw new Error("initializeWasm() must be awaited first!");
12761 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
12762 // debug statements here
12764 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
12766 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
12767 if(!isWasmInitialized) {
12768 throw new Error("initializeWasm() must be awaited first!");
12770 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
12771 // debug statements here
12773 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
12775 export function COption_NetAddressZ_some(o: number): number {
12776 if(!isWasmInitialized) {
12777 throw new Error("initializeWasm() must be awaited first!");
12779 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
12780 return nativeResponseValue;
12782 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
12784 export function COption_NetAddressZ_none(): number {
12785 if(!isWasmInitialized) {
12786 throw new Error("initializeWasm() must be awaited first!");
12788 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
12789 return nativeResponseValue;
12791 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
12793 export function COption_NetAddressZ_free(_res: number): void {
12794 if(!isWasmInitialized) {
12795 throw new Error("initializeWasm() must be awaited first!");
12797 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
12798 // debug statements here
12800 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
12802 export function COption_NetAddressZ_clone_ptr(arg: number): number {
12803 if(!isWasmInitialized) {
12804 throw new Error("initializeWasm() must be awaited first!");
12806 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
12807 return nativeResponseValue;
12809 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
12811 export function COption_NetAddressZ_clone(orig: number): number {
12812 if(!isWasmInitialized) {
12813 throw new Error("initializeWasm() must be awaited first!");
12815 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
12816 return nativeResponseValue;
12818 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
12820 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
12821 if(!isWasmInitialized) {
12822 throw new Error("initializeWasm() must be awaited first!");
12824 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
12825 return nativeResponseValue;
12827 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12829 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
12830 if(!isWasmInitialized) {
12831 throw new Error("initializeWasm() must be awaited first!");
12833 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
12834 return nativeResponseValue;
12836 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
12838 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
12839 if(!isWasmInitialized) {
12840 throw new Error("initializeWasm() must be awaited first!");
12842 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
12843 return nativeResponseValue;
12845 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
12847 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
12848 if(!isWasmInitialized) {
12849 throw new Error("initializeWasm() must be awaited first!");
12851 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
12852 // debug statements here
12854 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
12856 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
12857 if(!isWasmInitialized) {
12858 throw new Error("initializeWasm() must be awaited first!");
12860 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
12861 return nativeResponseValue;
12863 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
12865 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
12866 if(!isWasmInitialized) {
12867 throw new Error("initializeWasm() must be awaited first!");
12869 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
12870 return nativeResponseValue;
12872 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
12874 export function CResult_NonePeerHandleErrorZ_ok(): number {
12875 if(!isWasmInitialized) {
12876 throw new Error("initializeWasm() must be awaited first!");
12878 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
12879 return nativeResponseValue;
12881 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
12883 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
12884 if(!isWasmInitialized) {
12885 throw new Error("initializeWasm() must be awaited first!");
12887 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
12888 return nativeResponseValue;
12890 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
12892 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
12893 if(!isWasmInitialized) {
12894 throw new Error("initializeWasm() must be awaited first!");
12896 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
12897 return nativeResponseValue;
12899 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
12901 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
12902 if(!isWasmInitialized) {
12903 throw new Error("initializeWasm() must be awaited first!");
12905 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
12906 // debug statements here
12908 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
12910 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
12911 if(!isWasmInitialized) {
12912 throw new Error("initializeWasm() must be awaited first!");
12914 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
12915 return nativeResponseValue;
12917 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
12919 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
12920 if(!isWasmInitialized) {
12921 throw new Error("initializeWasm() must be awaited first!");
12923 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
12924 return nativeResponseValue;
12926 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
12928 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
12929 if(!isWasmInitialized) {
12930 throw new Error("initializeWasm() must be awaited first!");
12932 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
12933 return nativeResponseValue;
12935 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12937 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
12938 if(!isWasmInitialized) {
12939 throw new Error("initializeWasm() must be awaited first!");
12941 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
12942 return nativeResponseValue;
12944 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
12946 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
12947 if(!isWasmInitialized) {
12948 throw new Error("initializeWasm() must be awaited first!");
12950 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
12951 return nativeResponseValue;
12953 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
12955 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
12956 if(!isWasmInitialized) {
12957 throw new Error("initializeWasm() must be awaited first!");
12959 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
12960 // debug statements here
12962 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
12964 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
12965 if(!isWasmInitialized) {
12966 throw new Error("initializeWasm() must be awaited first!");
12968 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
12969 return nativeResponseValue;
12971 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
12973 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
12974 if(!isWasmInitialized) {
12975 throw new Error("initializeWasm() must be awaited first!");
12977 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
12978 return nativeResponseValue;
12980 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
12982 export function CResult_NoneErrorZ_ok(): number {
12983 if(!isWasmInitialized) {
12984 throw new Error("initializeWasm() must be awaited first!");
12986 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
12987 return nativeResponseValue;
12989 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
12991 export function CResult_NoneErrorZ_err(e: IOError): number {
12992 if(!isWasmInitialized) {
12993 throw new Error("initializeWasm() must be awaited first!");
12995 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
12996 return nativeResponseValue;
12998 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
13000 export function CResult_NoneErrorZ_is_ok(o: number): boolean {
13001 if(!isWasmInitialized) {
13002 throw new Error("initializeWasm() must be awaited first!");
13004 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13005 return nativeResponseValue;
13007 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13009 export function CResult_NoneErrorZ_free(_res: number): void {
13010 if(!isWasmInitialized) {
13011 throw new Error("initializeWasm() must be awaited first!");
13013 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13014 // debug statements here
13016 // uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13018 export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
13019 if(!isWasmInitialized) {
13020 throw new Error("initializeWasm() must be awaited first!");
13022 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13023 return nativeResponseValue;
13025 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13027 export function CResult_NoneErrorZ_clone(orig: number): number {
13028 if(!isWasmInitialized) {
13029 throw new Error("initializeWasm() must be awaited first!");
13031 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13032 return nativeResponseValue;
13034 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13036 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
13037 if(!isWasmInitialized) {
13038 throw new Error("initializeWasm() must be awaited first!");
13040 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13041 return nativeResponseValue;
13043 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13045 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
13046 if(!isWasmInitialized) {
13047 throw new Error("initializeWasm() must be awaited first!");
13049 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13050 return nativeResponseValue;
13052 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13054 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
13055 if(!isWasmInitialized) {
13056 throw new Error("initializeWasm() must be awaited first!");
13058 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13059 return nativeResponseValue;
13061 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13063 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
13064 if(!isWasmInitialized) {
13065 throw new Error("initializeWasm() must be awaited first!");
13067 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13068 // debug statements here
13070 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13072 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
13073 if(!isWasmInitialized) {
13074 throw new Error("initializeWasm() must be awaited first!");
13076 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13077 return nativeResponseValue;
13079 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13081 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
13082 if(!isWasmInitialized) {
13083 throw new Error("initializeWasm() must be awaited first!");
13085 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13086 return nativeResponseValue;
13088 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13090 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13091 if(!isWasmInitialized) {
13092 throw new Error("initializeWasm() must be awaited first!");
13094 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13095 // debug statements here
13097 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13099 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13100 if(!isWasmInitialized) {
13101 throw new Error("initializeWasm() must be awaited first!");
13103 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13104 // debug statements here
13106 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13108 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13109 if(!isWasmInitialized) {
13110 throw new Error("initializeWasm() must be awaited first!");
13112 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13113 // debug statements here
13115 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13117 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13118 if(!isWasmInitialized) {
13119 throw new Error("initializeWasm() must be awaited first!");
13121 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13122 // debug statements here
13124 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13126 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
13127 if(!isWasmInitialized) {
13128 throw new Error("initializeWasm() must be awaited first!");
13130 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13131 return nativeResponseValue;
13133 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13135 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
13136 if(!isWasmInitialized) {
13137 throw new Error("initializeWasm() must be awaited first!");
13139 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13140 return nativeResponseValue;
13142 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13144 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
13145 if(!isWasmInitialized) {
13146 throw new Error("initializeWasm() must be awaited first!");
13148 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13149 return nativeResponseValue;
13151 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13153 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
13154 if(!isWasmInitialized) {
13155 throw new Error("initializeWasm() must be awaited first!");
13157 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13158 // debug statements here
13160 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13162 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
13163 if(!isWasmInitialized) {
13164 throw new Error("initializeWasm() must be awaited first!");
13166 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13167 return nativeResponseValue;
13169 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13171 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
13172 if(!isWasmInitialized) {
13173 throw new Error("initializeWasm() must be awaited first!");
13175 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13176 return nativeResponseValue;
13178 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13180 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
13181 if(!isWasmInitialized) {
13182 throw new Error("initializeWasm() must be awaited first!");
13184 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13185 return nativeResponseValue;
13187 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13189 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
13190 if(!isWasmInitialized) {
13191 throw new Error("initializeWasm() must be awaited first!");
13193 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13194 return nativeResponseValue;
13196 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13198 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
13199 if(!isWasmInitialized) {
13200 throw new Error("initializeWasm() must be awaited first!");
13202 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13203 return nativeResponseValue;
13205 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13207 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
13208 if(!isWasmInitialized) {
13209 throw new Error("initializeWasm() must be awaited first!");
13211 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13212 // debug statements here
13214 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13216 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
13217 if(!isWasmInitialized) {
13218 throw new Error("initializeWasm() must be awaited first!");
13220 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13221 return nativeResponseValue;
13223 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13225 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
13226 if(!isWasmInitialized) {
13227 throw new Error("initializeWasm() must be awaited first!");
13229 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13230 return nativeResponseValue;
13232 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13234 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
13235 if(!isWasmInitialized) {
13236 throw new Error("initializeWasm() must be awaited first!");
13238 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13239 return nativeResponseValue;
13241 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13243 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
13244 if(!isWasmInitialized) {
13245 throw new Error("initializeWasm() must be awaited first!");
13247 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13248 return nativeResponseValue;
13250 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13252 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
13253 if(!isWasmInitialized) {
13254 throw new Error("initializeWasm() must be awaited first!");
13256 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13257 return nativeResponseValue;
13259 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13261 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
13262 if(!isWasmInitialized) {
13263 throw new Error("initializeWasm() must be awaited first!");
13265 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13266 // debug statements here
13268 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13270 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
13271 if(!isWasmInitialized) {
13272 throw new Error("initializeWasm() must be awaited first!");
13274 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13275 return nativeResponseValue;
13277 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13279 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
13280 if(!isWasmInitialized) {
13281 throw new Error("initializeWasm() must be awaited first!");
13283 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13284 return nativeResponseValue;
13286 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13288 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
13289 if(!isWasmInitialized) {
13290 throw new Error("initializeWasm() must be awaited first!");
13292 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13293 return nativeResponseValue;
13295 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13297 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
13298 if(!isWasmInitialized) {
13299 throw new Error("initializeWasm() must be awaited first!");
13301 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13302 return nativeResponseValue;
13304 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13306 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
13307 if(!isWasmInitialized) {
13308 throw new Error("initializeWasm() must be awaited first!");
13310 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13311 return nativeResponseValue;
13313 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13315 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
13316 if(!isWasmInitialized) {
13317 throw new Error("initializeWasm() must be awaited first!");
13319 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13320 // debug statements here
13322 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13324 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13325 if(!isWasmInitialized) {
13326 throw new Error("initializeWasm() must be awaited first!");
13328 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13329 return nativeResponseValue;
13331 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13333 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
13334 if(!isWasmInitialized) {
13335 throw new Error("initializeWasm() must be awaited first!");
13337 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13338 return nativeResponseValue;
13340 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13342 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13343 if(!isWasmInitialized) {
13344 throw new Error("initializeWasm() must be awaited first!");
13346 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13347 return nativeResponseValue;
13349 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13351 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13352 if(!isWasmInitialized) {
13353 throw new Error("initializeWasm() must be awaited first!");
13355 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13356 return nativeResponseValue;
13358 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13360 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13361 if(!isWasmInitialized) {
13362 throw new Error("initializeWasm() must be awaited first!");
13364 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13365 return nativeResponseValue;
13367 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13369 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13370 if(!isWasmInitialized) {
13371 throw new Error("initializeWasm() must be awaited first!");
13373 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13374 // debug statements here
13376 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13378 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13379 if(!isWasmInitialized) {
13380 throw new Error("initializeWasm() must be awaited first!");
13382 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13383 return nativeResponseValue;
13385 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13387 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13388 if(!isWasmInitialized) {
13389 throw new Error("initializeWasm() must be awaited first!");
13391 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13392 return nativeResponseValue;
13394 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13396 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13397 if(!isWasmInitialized) {
13398 throw new Error("initializeWasm() must be awaited first!");
13400 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13401 return nativeResponseValue;
13403 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13405 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13406 if(!isWasmInitialized) {
13407 throw new Error("initializeWasm() must be awaited first!");
13409 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13410 return nativeResponseValue;
13412 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13414 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13415 if(!isWasmInitialized) {
13416 throw new Error("initializeWasm() must be awaited first!");
13418 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13419 return nativeResponseValue;
13421 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13423 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13424 if(!isWasmInitialized) {
13425 throw new Error("initializeWasm() must be awaited first!");
13427 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13428 // debug statements here
13430 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13432 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13433 if(!isWasmInitialized) {
13434 throw new Error("initializeWasm() must be awaited first!");
13436 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13437 return nativeResponseValue;
13439 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13441 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13442 if(!isWasmInitialized) {
13443 throw new Error("initializeWasm() must be awaited first!");
13445 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13446 return nativeResponseValue;
13448 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13450 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13451 if(!isWasmInitialized) {
13452 throw new Error("initializeWasm() must be awaited first!");
13454 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13455 return nativeResponseValue;
13457 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
13459 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
13460 if(!isWasmInitialized) {
13461 throw new Error("initializeWasm() must be awaited first!");
13463 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
13464 return nativeResponseValue;
13466 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
13468 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
13469 if(!isWasmInitialized) {
13470 throw new Error("initializeWasm() must be awaited first!");
13472 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
13473 return nativeResponseValue;
13475 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
13477 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
13478 if(!isWasmInitialized) {
13479 throw new Error("initializeWasm() must be awaited first!");
13481 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
13482 // debug statements here
13484 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
13486 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
13487 if(!isWasmInitialized) {
13488 throw new Error("initializeWasm() must be awaited first!");
13490 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
13491 return nativeResponseValue;
13493 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
13495 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
13496 if(!isWasmInitialized) {
13497 throw new Error("initializeWasm() must be awaited first!");
13499 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
13500 return nativeResponseValue;
13502 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
13504 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
13505 if(!isWasmInitialized) {
13506 throw new Error("initializeWasm() must be awaited first!");
13508 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
13509 return nativeResponseValue;
13511 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13513 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
13514 if(!isWasmInitialized) {
13515 throw new Error("initializeWasm() must be awaited first!");
13517 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
13518 return nativeResponseValue;
13520 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
13522 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
13523 if(!isWasmInitialized) {
13524 throw new Error("initializeWasm() must be awaited first!");
13526 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
13527 return nativeResponseValue;
13529 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
13531 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
13532 if(!isWasmInitialized) {
13533 throw new Error("initializeWasm() must be awaited first!");
13535 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
13536 // debug statements here
13538 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
13540 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13541 if(!isWasmInitialized) {
13542 throw new Error("initializeWasm() must be awaited first!");
13544 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13545 return nativeResponseValue;
13547 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13549 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13550 if(!isWasmInitialized) {
13551 throw new Error("initializeWasm() must be awaited first!");
13553 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13554 return nativeResponseValue;
13556 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
13558 export function CResult_ChannelReadyDecodeErrorZ_ok(o: number): number {
13559 if(!isWasmInitialized) {
13560 throw new Error("initializeWasm() must be awaited first!");
13562 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
13563 return nativeResponseValue;
13565 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
13567 export function CResult_ChannelReadyDecodeErrorZ_err(e: number): number {
13568 if(!isWasmInitialized) {
13569 throw new Error("initializeWasm() must be awaited first!");
13571 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
13572 return nativeResponseValue;
13574 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
13576 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: number): boolean {
13577 if(!isWasmInitialized) {
13578 throw new Error("initializeWasm() must be awaited first!");
13580 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
13581 return nativeResponseValue;
13583 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
13585 export function CResult_ChannelReadyDecodeErrorZ_free(_res: number): void {
13586 if(!isWasmInitialized) {
13587 throw new Error("initializeWasm() must be awaited first!");
13589 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
13590 // debug statements here
13592 // uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
13594 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: number): number {
13595 if(!isWasmInitialized) {
13596 throw new Error("initializeWasm() must be awaited first!");
13598 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
13599 return nativeResponseValue;
13601 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
13603 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: number): number {
13604 if(!isWasmInitialized) {
13605 throw new Error("initializeWasm() must be awaited first!");
13607 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
13608 return nativeResponseValue;
13610 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13612 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13613 if(!isWasmInitialized) {
13614 throw new Error("initializeWasm() must be awaited first!");
13616 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13617 return nativeResponseValue;
13619 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13621 export function CResult_InitDecodeErrorZ_err(e: number): number {
13622 if(!isWasmInitialized) {
13623 throw new Error("initializeWasm() must be awaited first!");
13625 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13626 return nativeResponseValue;
13628 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13630 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13631 if(!isWasmInitialized) {
13632 throw new Error("initializeWasm() must be awaited first!");
13634 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13635 return nativeResponseValue;
13637 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13639 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13640 if(!isWasmInitialized) {
13641 throw new Error("initializeWasm() must be awaited first!");
13643 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13644 // debug statements here
13646 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13648 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13649 if(!isWasmInitialized) {
13650 throw new Error("initializeWasm() must be awaited first!");
13652 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13653 return nativeResponseValue;
13655 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13657 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13658 if(!isWasmInitialized) {
13659 throw new Error("initializeWasm() must be awaited first!");
13661 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13662 return nativeResponseValue;
13664 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13666 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13667 if(!isWasmInitialized) {
13668 throw new Error("initializeWasm() must be awaited first!");
13670 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13671 return nativeResponseValue;
13673 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13675 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13676 if(!isWasmInitialized) {
13677 throw new Error("initializeWasm() must be awaited first!");
13679 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13680 return nativeResponseValue;
13682 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13684 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13685 if(!isWasmInitialized) {
13686 throw new Error("initializeWasm() must be awaited first!");
13688 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13689 return nativeResponseValue;
13691 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13693 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13694 if(!isWasmInitialized) {
13695 throw new Error("initializeWasm() must be awaited first!");
13697 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13698 // debug statements here
13700 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13702 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13703 if(!isWasmInitialized) {
13704 throw new Error("initializeWasm() must be awaited first!");
13706 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13707 return nativeResponseValue;
13709 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13711 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13712 if(!isWasmInitialized) {
13713 throw new Error("initializeWasm() must be awaited first!");
13715 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13716 return nativeResponseValue;
13718 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13720 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13721 if(!isWasmInitialized) {
13722 throw new Error("initializeWasm() must be awaited first!");
13724 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13725 return nativeResponseValue;
13727 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13729 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13730 if(!isWasmInitialized) {
13731 throw new Error("initializeWasm() must be awaited first!");
13733 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13734 return nativeResponseValue;
13736 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13738 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13739 if(!isWasmInitialized) {
13740 throw new Error("initializeWasm() must be awaited first!");
13742 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13743 return nativeResponseValue;
13745 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13747 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13748 if(!isWasmInitialized) {
13749 throw new Error("initializeWasm() must be awaited first!");
13751 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13752 // debug statements here
13754 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
13756 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
13757 if(!isWasmInitialized) {
13758 throw new Error("initializeWasm() must be awaited first!");
13760 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
13761 return nativeResponseValue;
13763 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
13765 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
13766 if(!isWasmInitialized) {
13767 throw new Error("initializeWasm() must be awaited first!");
13769 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
13770 return nativeResponseValue;
13772 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
13774 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
13775 if(!isWasmInitialized) {
13776 throw new Error("initializeWasm() must be awaited first!");
13778 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
13779 return nativeResponseValue;
13781 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
13783 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
13784 if(!isWasmInitialized) {
13785 throw new Error("initializeWasm() must be awaited first!");
13787 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
13788 return nativeResponseValue;
13790 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
13792 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
13793 if(!isWasmInitialized) {
13794 throw new Error("initializeWasm() must be awaited first!");
13796 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
13797 return nativeResponseValue;
13799 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
13801 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
13802 if(!isWasmInitialized) {
13803 throw new Error("initializeWasm() must be awaited first!");
13805 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
13806 // debug statements here
13808 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
13810 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
13811 if(!isWasmInitialized) {
13812 throw new Error("initializeWasm() must be awaited first!");
13814 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
13815 return nativeResponseValue;
13817 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
13819 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
13820 if(!isWasmInitialized) {
13821 throw new Error("initializeWasm() must be awaited first!");
13823 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
13824 return nativeResponseValue;
13826 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
13828 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
13829 if(!isWasmInitialized) {
13830 throw new Error("initializeWasm() must be awaited first!");
13832 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
13833 return nativeResponseValue;
13835 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13837 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
13838 if(!isWasmInitialized) {
13839 throw new Error("initializeWasm() must be awaited first!");
13841 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
13842 return nativeResponseValue;
13844 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
13846 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
13847 if(!isWasmInitialized) {
13848 throw new Error("initializeWasm() must be awaited first!");
13850 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
13851 return nativeResponseValue;
13853 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
13855 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
13856 if(!isWasmInitialized) {
13857 throw new Error("initializeWasm() must be awaited first!");
13859 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
13860 // debug statements here
13862 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
13864 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13865 if(!isWasmInitialized) {
13866 throw new Error("initializeWasm() must be awaited first!");
13868 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
13869 return nativeResponseValue;
13871 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
13873 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
13874 if(!isWasmInitialized) {
13875 throw new Error("initializeWasm() must be awaited first!");
13877 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
13878 return nativeResponseValue;
13880 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
13882 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
13883 if(!isWasmInitialized) {
13884 throw new Error("initializeWasm() must be awaited first!");
13886 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
13887 return nativeResponseValue;
13889 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13891 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
13892 if(!isWasmInitialized) {
13893 throw new Error("initializeWasm() must be awaited first!");
13895 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
13896 return nativeResponseValue;
13898 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
13900 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
13901 if(!isWasmInitialized) {
13902 throw new Error("initializeWasm() must be awaited first!");
13904 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
13905 return nativeResponseValue;
13907 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
13909 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
13910 if(!isWasmInitialized) {
13911 throw new Error("initializeWasm() must be awaited first!");
13913 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
13914 // debug statements here
13916 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
13918 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13919 if(!isWasmInitialized) {
13920 throw new Error("initializeWasm() must be awaited first!");
13922 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
13923 return nativeResponseValue;
13925 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
13927 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
13928 if(!isWasmInitialized) {
13929 throw new Error("initializeWasm() must be awaited first!");
13931 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
13932 return nativeResponseValue;
13934 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
13936 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
13937 if(!isWasmInitialized) {
13938 throw new Error("initializeWasm() must be awaited first!");
13940 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
13941 return nativeResponseValue;
13943 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
13945 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
13946 if(!isWasmInitialized) {
13947 throw new Error("initializeWasm() must be awaited first!");
13949 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
13950 return nativeResponseValue;
13952 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
13954 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
13955 if(!isWasmInitialized) {
13956 throw new Error("initializeWasm() must be awaited first!");
13958 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
13959 return nativeResponseValue;
13961 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
13963 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
13964 if(!isWasmInitialized) {
13965 throw new Error("initializeWasm() must be awaited first!");
13967 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
13968 // debug statements here
13970 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
13972 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
13973 if(!isWasmInitialized) {
13974 throw new Error("initializeWasm() must be awaited first!");
13976 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
13977 return nativeResponseValue;
13979 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
13981 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
13982 if(!isWasmInitialized) {
13983 throw new Error("initializeWasm() must be awaited first!");
13985 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
13986 return nativeResponseValue;
13988 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
13990 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
13991 if(!isWasmInitialized) {
13992 throw new Error("initializeWasm() must be awaited first!");
13994 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
13995 return nativeResponseValue;
13997 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13999 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
14000 if(!isWasmInitialized) {
14001 throw new Error("initializeWasm() must be awaited first!");
14003 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14004 return nativeResponseValue;
14006 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14008 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
14009 if(!isWasmInitialized) {
14010 throw new Error("initializeWasm() must be awaited first!");
14012 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14013 return nativeResponseValue;
14015 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14017 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
14018 if(!isWasmInitialized) {
14019 throw new Error("initializeWasm() must be awaited first!");
14021 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14022 // debug statements here
14024 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14026 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14027 if(!isWasmInitialized) {
14028 throw new Error("initializeWasm() must be awaited first!");
14030 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14031 return nativeResponseValue;
14033 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14035 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
14036 if(!isWasmInitialized) {
14037 throw new Error("initializeWasm() must be awaited first!");
14039 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14040 return nativeResponseValue;
14042 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14044 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
14045 if(!isWasmInitialized) {
14046 throw new Error("initializeWasm() must be awaited first!");
14048 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14049 return nativeResponseValue;
14051 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14053 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
14054 if(!isWasmInitialized) {
14055 throw new Error("initializeWasm() must be awaited first!");
14057 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14058 return nativeResponseValue;
14060 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14062 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
14063 if(!isWasmInitialized) {
14064 throw new Error("initializeWasm() must be awaited first!");
14066 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14067 return nativeResponseValue;
14069 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14071 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
14072 if(!isWasmInitialized) {
14073 throw new Error("initializeWasm() must be awaited first!");
14075 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14076 // debug statements here
14078 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14080 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14081 if(!isWasmInitialized) {
14082 throw new Error("initializeWasm() must be awaited first!");
14084 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14085 return nativeResponseValue;
14087 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14089 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
14090 if(!isWasmInitialized) {
14091 throw new Error("initializeWasm() must be awaited first!");
14093 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14094 return nativeResponseValue;
14096 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14098 export function CResult_PingDecodeErrorZ_ok(o: number): number {
14099 if(!isWasmInitialized) {
14100 throw new Error("initializeWasm() must be awaited first!");
14102 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14103 return nativeResponseValue;
14105 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14107 export function CResult_PingDecodeErrorZ_err(e: number): number {
14108 if(!isWasmInitialized) {
14109 throw new Error("initializeWasm() must be awaited first!");
14111 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14112 return nativeResponseValue;
14114 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14116 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
14117 if(!isWasmInitialized) {
14118 throw new Error("initializeWasm() must be awaited first!");
14120 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14121 return nativeResponseValue;
14123 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14125 export function CResult_PingDecodeErrorZ_free(_res: number): void {
14126 if(!isWasmInitialized) {
14127 throw new Error("initializeWasm() must be awaited first!");
14129 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14130 // debug statements here
14132 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14134 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
14135 if(!isWasmInitialized) {
14136 throw new Error("initializeWasm() must be awaited first!");
14138 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14139 return nativeResponseValue;
14141 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14143 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
14144 if(!isWasmInitialized) {
14145 throw new Error("initializeWasm() must be awaited first!");
14147 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14148 return nativeResponseValue;
14150 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14152 export function CResult_PongDecodeErrorZ_ok(o: number): number {
14153 if(!isWasmInitialized) {
14154 throw new Error("initializeWasm() must be awaited first!");
14156 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14157 return nativeResponseValue;
14159 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14161 export function CResult_PongDecodeErrorZ_err(e: number): number {
14162 if(!isWasmInitialized) {
14163 throw new Error("initializeWasm() must be awaited first!");
14165 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14166 return nativeResponseValue;
14168 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14170 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
14171 if(!isWasmInitialized) {
14172 throw new Error("initializeWasm() must be awaited first!");
14174 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14175 return nativeResponseValue;
14177 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14179 export function CResult_PongDecodeErrorZ_free(_res: number): void {
14180 if(!isWasmInitialized) {
14181 throw new Error("initializeWasm() must be awaited first!");
14183 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14184 // debug statements here
14186 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14188 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
14189 if(!isWasmInitialized) {
14190 throw new Error("initializeWasm() must be awaited first!");
14192 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14193 return nativeResponseValue;
14195 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14197 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
14198 if(!isWasmInitialized) {
14199 throw new Error("initializeWasm() must be awaited first!");
14201 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14202 return nativeResponseValue;
14204 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14206 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14207 if(!isWasmInitialized) {
14208 throw new Error("initializeWasm() must be awaited first!");
14210 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14211 return nativeResponseValue;
14213 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14215 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
14216 if(!isWasmInitialized) {
14217 throw new Error("initializeWasm() must be awaited first!");
14219 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14220 return nativeResponseValue;
14222 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14224 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14225 if(!isWasmInitialized) {
14226 throw new Error("initializeWasm() must be awaited first!");
14228 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14229 return nativeResponseValue;
14231 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14233 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14234 if(!isWasmInitialized) {
14235 throw new Error("initializeWasm() must be awaited first!");
14237 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14238 // debug statements here
14240 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14242 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14243 if(!isWasmInitialized) {
14244 throw new Error("initializeWasm() must be awaited first!");
14246 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14247 return nativeResponseValue;
14249 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14251 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14252 if(!isWasmInitialized) {
14253 throw new Error("initializeWasm() must be awaited first!");
14255 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14256 return nativeResponseValue;
14258 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14260 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14261 if(!isWasmInitialized) {
14262 throw new Error("initializeWasm() must be awaited first!");
14264 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14265 return nativeResponseValue;
14267 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14269 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
14270 if(!isWasmInitialized) {
14271 throw new Error("initializeWasm() must be awaited first!");
14273 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14274 return nativeResponseValue;
14276 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14278 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14279 if(!isWasmInitialized) {
14280 throw new Error("initializeWasm() must be awaited first!");
14282 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14283 return nativeResponseValue;
14285 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14287 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14288 if(!isWasmInitialized) {
14289 throw new Error("initializeWasm() must be awaited first!");
14291 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14292 // debug statements here
14294 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14296 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14297 if(!isWasmInitialized) {
14298 throw new Error("initializeWasm() must be awaited first!");
14300 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14301 return nativeResponseValue;
14303 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14305 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14306 if(!isWasmInitialized) {
14307 throw new Error("initializeWasm() must be awaited first!");
14309 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14310 return nativeResponseValue;
14312 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14314 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
14315 if(!isWasmInitialized) {
14316 throw new Error("initializeWasm() must be awaited first!");
14318 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14319 return nativeResponseValue;
14321 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14323 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
14324 if(!isWasmInitialized) {
14325 throw new Error("initializeWasm() must be awaited first!");
14327 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14328 return nativeResponseValue;
14330 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14332 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14333 if(!isWasmInitialized) {
14334 throw new Error("initializeWasm() must be awaited first!");
14336 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14337 return nativeResponseValue;
14339 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14341 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14342 if(!isWasmInitialized) {
14343 throw new Error("initializeWasm() must be awaited first!");
14345 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14346 // debug statements here
14348 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14350 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14351 if(!isWasmInitialized) {
14352 throw new Error("initializeWasm() must be awaited first!");
14354 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14355 return nativeResponseValue;
14357 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14359 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14360 if(!isWasmInitialized) {
14361 throw new Error("initializeWasm() must be awaited first!");
14363 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14364 return nativeResponseValue;
14366 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14368 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14369 if(!isWasmInitialized) {
14370 throw new Error("initializeWasm() must be awaited first!");
14372 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14373 return nativeResponseValue;
14375 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14377 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14378 if(!isWasmInitialized) {
14379 throw new Error("initializeWasm() must be awaited first!");
14381 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14382 return nativeResponseValue;
14384 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14386 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14387 if(!isWasmInitialized) {
14388 throw new Error("initializeWasm() must be awaited first!");
14390 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14391 return nativeResponseValue;
14393 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14395 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14396 if(!isWasmInitialized) {
14397 throw new Error("initializeWasm() must be awaited first!");
14399 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14400 // debug statements here
14402 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14404 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14405 if(!isWasmInitialized) {
14406 throw new Error("initializeWasm() must be awaited first!");
14408 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14409 return nativeResponseValue;
14411 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14413 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14414 if(!isWasmInitialized) {
14415 throw new Error("initializeWasm() must be awaited first!");
14417 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14418 return nativeResponseValue;
14420 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14422 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14423 if(!isWasmInitialized) {
14424 throw new Error("initializeWasm() must be awaited first!");
14426 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14427 return nativeResponseValue;
14429 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14431 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14432 if(!isWasmInitialized) {
14433 throw new Error("initializeWasm() must be awaited first!");
14435 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
14436 return nativeResponseValue;
14438 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14440 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14441 if(!isWasmInitialized) {
14442 throw new Error("initializeWasm() must be awaited first!");
14444 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14445 return nativeResponseValue;
14447 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14449 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14450 if(!isWasmInitialized) {
14451 throw new Error("initializeWasm() must be awaited first!");
14453 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14454 // debug statements here
14456 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
14458 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
14459 if(!isWasmInitialized) {
14460 throw new Error("initializeWasm() must be awaited first!");
14462 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
14463 return nativeResponseValue;
14465 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
14467 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
14468 if(!isWasmInitialized) {
14469 throw new Error("initializeWasm() must be awaited first!");
14471 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
14472 return nativeResponseValue;
14474 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
14476 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
14477 if(!isWasmInitialized) {
14478 throw new Error("initializeWasm() must be awaited first!");
14480 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
14481 return nativeResponseValue;
14483 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
14485 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
14486 if(!isWasmInitialized) {
14487 throw new Error("initializeWasm() must be awaited first!");
14489 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
14490 return nativeResponseValue;
14492 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
14494 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
14495 if(!isWasmInitialized) {
14496 throw new Error("initializeWasm() must be awaited first!");
14498 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
14499 return nativeResponseValue;
14501 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
14503 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
14504 if(!isWasmInitialized) {
14505 throw new Error("initializeWasm() must be awaited first!");
14507 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
14508 // debug statements here
14510 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
14512 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
14513 if(!isWasmInitialized) {
14514 throw new Error("initializeWasm() must be awaited first!");
14516 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
14517 return nativeResponseValue;
14519 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
14521 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
14522 if(!isWasmInitialized) {
14523 throw new Error("initializeWasm() must be awaited first!");
14525 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
14526 return nativeResponseValue;
14528 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
14530 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
14531 if(!isWasmInitialized) {
14532 throw new Error("initializeWasm() must be awaited first!");
14534 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
14535 return nativeResponseValue;
14537 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14539 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
14540 if(!isWasmInitialized) {
14541 throw new Error("initializeWasm() must be awaited first!");
14543 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
14544 return nativeResponseValue;
14546 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14548 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14549 if(!isWasmInitialized) {
14550 throw new Error("initializeWasm() must be awaited first!");
14552 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14553 return nativeResponseValue;
14555 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14557 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14558 if(!isWasmInitialized) {
14559 throw new Error("initializeWasm() must be awaited first!");
14561 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14562 // debug statements here
14564 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14566 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14567 if(!isWasmInitialized) {
14568 throw new Error("initializeWasm() must be awaited first!");
14570 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14571 return nativeResponseValue;
14573 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14575 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14576 if(!isWasmInitialized) {
14577 throw new Error("initializeWasm() must be awaited first!");
14579 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14580 return nativeResponseValue;
14582 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14584 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14585 if(!isWasmInitialized) {
14586 throw new Error("initializeWasm() must be awaited first!");
14588 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14589 return nativeResponseValue;
14591 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14593 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14594 if(!isWasmInitialized) {
14595 throw new Error("initializeWasm() must be awaited first!");
14597 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14598 return nativeResponseValue;
14600 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14602 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14603 if(!isWasmInitialized) {
14604 throw new Error("initializeWasm() must be awaited first!");
14606 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14607 return nativeResponseValue;
14609 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14611 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14612 if(!isWasmInitialized) {
14613 throw new Error("initializeWasm() must be awaited first!");
14615 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14616 // debug statements here
14618 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14620 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14621 if(!isWasmInitialized) {
14622 throw new Error("initializeWasm() must be awaited first!");
14624 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14625 return nativeResponseValue;
14627 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14629 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14630 if(!isWasmInitialized) {
14631 throw new Error("initializeWasm() must be awaited first!");
14633 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14634 return nativeResponseValue;
14636 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14638 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14639 if(!isWasmInitialized) {
14640 throw new Error("initializeWasm() must be awaited first!");
14642 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14643 return nativeResponseValue;
14645 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14647 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14648 if(!isWasmInitialized) {
14649 throw new Error("initializeWasm() must be awaited first!");
14651 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14652 return nativeResponseValue;
14654 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14656 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14657 if(!isWasmInitialized) {
14658 throw new Error("initializeWasm() must be awaited first!");
14660 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14661 return nativeResponseValue;
14663 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14665 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14666 if(!isWasmInitialized) {
14667 throw new Error("initializeWasm() must be awaited first!");
14669 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14670 // debug statements here
14672 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14674 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14675 if(!isWasmInitialized) {
14676 throw new Error("initializeWasm() must be awaited first!");
14678 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14679 return nativeResponseValue;
14681 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14683 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14684 if(!isWasmInitialized) {
14685 throw new Error("initializeWasm() must be awaited first!");
14687 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14688 return nativeResponseValue;
14690 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14692 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14693 if(!isWasmInitialized) {
14694 throw new Error("initializeWasm() must be awaited first!");
14696 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14697 return nativeResponseValue;
14699 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14701 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14702 if(!isWasmInitialized) {
14703 throw new Error("initializeWasm() must be awaited first!");
14705 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14706 return nativeResponseValue;
14708 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14710 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14711 if(!isWasmInitialized) {
14712 throw new Error("initializeWasm() must be awaited first!");
14714 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14715 return nativeResponseValue;
14717 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14719 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14720 if(!isWasmInitialized) {
14721 throw new Error("initializeWasm() must be awaited first!");
14723 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14724 // debug statements here
14726 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14728 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14729 if(!isWasmInitialized) {
14730 throw new Error("initializeWasm() must be awaited first!");
14732 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14733 return nativeResponseValue;
14735 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14737 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14738 if(!isWasmInitialized) {
14739 throw new Error("initializeWasm() must be awaited first!");
14741 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14742 return nativeResponseValue;
14744 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14746 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14747 if(!isWasmInitialized) {
14748 throw new Error("initializeWasm() must be awaited first!");
14750 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14751 return nativeResponseValue;
14753 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14755 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
14756 if(!isWasmInitialized) {
14757 throw new Error("initializeWasm() must be awaited first!");
14759 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
14760 return nativeResponseValue;
14762 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
14764 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14765 if(!isWasmInitialized) {
14766 throw new Error("initializeWasm() must be awaited first!");
14768 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
14769 return nativeResponseValue;
14771 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
14773 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
14774 if(!isWasmInitialized) {
14775 throw new Error("initializeWasm() must be awaited first!");
14777 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
14778 // debug statements here
14780 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14782 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14783 if(!isWasmInitialized) {
14784 throw new Error("initializeWasm() must be awaited first!");
14786 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
14787 return nativeResponseValue;
14789 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14791 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
14792 if(!isWasmInitialized) {
14793 throw new Error("initializeWasm() must be awaited first!");
14795 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
14796 return nativeResponseValue;
14798 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
14800 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
14801 if(!isWasmInitialized) {
14802 throw new Error("initializeWasm() must be awaited first!");
14804 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
14805 return nativeResponseValue;
14807 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14809 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
14810 if(!isWasmInitialized) {
14811 throw new Error("initializeWasm() must be awaited first!");
14813 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
14814 return nativeResponseValue;
14816 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
14818 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14819 if(!isWasmInitialized) {
14820 throw new Error("initializeWasm() must be awaited first!");
14822 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
14823 return nativeResponseValue;
14825 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
14827 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
14828 if(!isWasmInitialized) {
14829 throw new Error("initializeWasm() must be awaited first!");
14831 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
14832 // debug statements here
14834 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14836 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14837 if(!isWasmInitialized) {
14838 throw new Error("initializeWasm() must be awaited first!");
14840 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
14841 return nativeResponseValue;
14843 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14845 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
14846 if(!isWasmInitialized) {
14847 throw new Error("initializeWasm() must be awaited first!");
14849 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
14850 return nativeResponseValue;
14852 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
14854 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
14855 if(!isWasmInitialized) {
14856 throw new Error("initializeWasm() must be awaited first!");
14858 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
14859 return nativeResponseValue;
14861 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
14863 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
14864 if(!isWasmInitialized) {
14865 throw new Error("initializeWasm() must be awaited first!");
14867 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
14868 return nativeResponseValue;
14870 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
14872 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
14873 if(!isWasmInitialized) {
14874 throw new Error("initializeWasm() must be awaited first!");
14876 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
14877 return nativeResponseValue;
14879 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
14881 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
14882 if(!isWasmInitialized) {
14883 throw new Error("initializeWasm() must be awaited first!");
14885 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
14886 // debug statements here
14888 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
14890 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
14891 if(!isWasmInitialized) {
14892 throw new Error("initializeWasm() must be awaited first!");
14894 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
14895 return nativeResponseValue;
14897 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
14899 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
14900 if(!isWasmInitialized) {
14901 throw new Error("initializeWasm() must be awaited first!");
14903 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
14904 return nativeResponseValue;
14906 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
14908 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
14909 if(!isWasmInitialized) {
14910 throw new Error("initializeWasm() must be awaited first!");
14912 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
14913 return nativeResponseValue;
14915 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
14917 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
14918 if(!isWasmInitialized) {
14919 throw new Error("initializeWasm() must be awaited first!");
14921 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
14922 return nativeResponseValue;
14924 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
14926 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
14927 if(!isWasmInitialized) {
14928 throw new Error("initializeWasm() must be awaited first!");
14930 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
14931 return nativeResponseValue;
14933 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
14935 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
14936 if(!isWasmInitialized) {
14937 throw new Error("initializeWasm() must be awaited first!");
14939 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
14940 // debug statements here
14942 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
14944 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
14945 if(!isWasmInitialized) {
14946 throw new Error("initializeWasm() must be awaited first!");
14948 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
14949 return nativeResponseValue;
14951 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
14953 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
14954 if(!isWasmInitialized) {
14955 throw new Error("initializeWasm() must be awaited first!");
14957 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
14958 return nativeResponseValue;
14960 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
14962 export function COption_FilterZ_some(o: number): number {
14963 if(!isWasmInitialized) {
14964 throw new Error("initializeWasm() must be awaited first!");
14966 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
14967 return nativeResponseValue;
14969 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
14971 export function COption_FilterZ_none(): number {
14972 if(!isWasmInitialized) {
14973 throw new Error("initializeWasm() must be awaited first!");
14975 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
14976 return nativeResponseValue;
14978 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
14980 export function COption_FilterZ_free(_res: number): void {
14981 if(!isWasmInitialized) {
14982 throw new Error("initializeWasm() must be awaited first!");
14984 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
14985 // debug statements here
14987 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
14989 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
14990 if(!isWasmInitialized) {
14991 throw new Error("initializeWasm() must be awaited first!");
14993 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
14994 return nativeResponseValue;
14996 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
14998 export function CResult_LockedChannelMonitorNoneZ_err(): number {
14999 if(!isWasmInitialized) {
15000 throw new Error("initializeWasm() must be awaited first!");
15002 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15003 return nativeResponseValue;
15005 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15007 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
15008 if(!isWasmInitialized) {
15009 throw new Error("initializeWasm() must be awaited first!");
15011 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15012 return nativeResponseValue;
15014 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15016 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
15017 if(!isWasmInitialized) {
15018 throw new Error("initializeWasm() must be awaited first!");
15020 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15021 // debug statements here
15023 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15025 export function CVec_OutPointZ_free(_res: number): void {
15026 if(!isWasmInitialized) {
15027 throw new Error("initializeWasm() must be awaited first!");
15029 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15030 // debug statements here
15032 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15034 export function PaymentPurpose_free(this_ptr: number): void {
15035 if(!isWasmInitialized) {
15036 throw new Error("initializeWasm() must be awaited first!");
15038 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15039 // debug statements here
15041 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15043 export function PaymentPurpose_clone_ptr(arg: number): number {
15044 if(!isWasmInitialized) {
15045 throw new Error("initializeWasm() must be awaited first!");
15047 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15048 return nativeResponseValue;
15050 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15052 export function PaymentPurpose_clone(orig: number): number {
15053 if(!isWasmInitialized) {
15054 throw new Error("initializeWasm() must be awaited first!");
15056 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15057 return nativeResponseValue;
15059 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15061 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
15062 if(!isWasmInitialized) {
15063 throw new Error("initializeWasm() must be awaited first!");
15065 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15066 return nativeResponseValue;
15068 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15070 export function PaymentPurpose_spontaneous_payment(a: number): number {
15071 if(!isWasmInitialized) {
15072 throw new Error("initializeWasm() must be awaited first!");
15074 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15075 return nativeResponseValue;
15077 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15079 export function PaymentPurpose_write(obj: number): number {
15080 if(!isWasmInitialized) {
15081 throw new Error("initializeWasm() must be awaited first!");
15083 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15084 return nativeResponseValue;
15086 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15088 export function PaymentPurpose_read(ser: number): number {
15089 if(!isWasmInitialized) {
15090 throw new Error("initializeWasm() must be awaited first!");
15092 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15093 return nativeResponseValue;
15095 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15097 export function ClosureReason_free(this_ptr: number): void {
15098 if(!isWasmInitialized) {
15099 throw new Error("initializeWasm() must be awaited first!");
15101 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15102 // debug statements here
15104 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15106 export function ClosureReason_clone_ptr(arg: number): number {
15107 if(!isWasmInitialized) {
15108 throw new Error("initializeWasm() must be awaited first!");
15110 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15111 return nativeResponseValue;
15113 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15115 export function ClosureReason_clone(orig: number): number {
15116 if(!isWasmInitialized) {
15117 throw new Error("initializeWasm() must be awaited first!");
15119 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15120 return nativeResponseValue;
15122 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15124 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
15125 if(!isWasmInitialized) {
15126 throw new Error("initializeWasm() must be awaited first!");
15128 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15129 return nativeResponseValue;
15131 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15133 export function ClosureReason_holder_force_closed(): number {
15134 if(!isWasmInitialized) {
15135 throw new Error("initializeWasm() must be awaited first!");
15137 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15138 return nativeResponseValue;
15140 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15142 export function ClosureReason_cooperative_closure(): number {
15143 if(!isWasmInitialized) {
15144 throw new Error("initializeWasm() must be awaited first!");
15146 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15147 return nativeResponseValue;
15149 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15151 export function ClosureReason_commitment_tx_confirmed(): number {
15152 if(!isWasmInitialized) {
15153 throw new Error("initializeWasm() must be awaited first!");
15155 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15156 return nativeResponseValue;
15158 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15160 export function ClosureReason_funding_timed_out(): number {
15161 if(!isWasmInitialized) {
15162 throw new Error("initializeWasm() must be awaited first!");
15164 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15165 return nativeResponseValue;
15167 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15169 export function ClosureReason_processing_error(err: number): number {
15170 if(!isWasmInitialized) {
15171 throw new Error("initializeWasm() must be awaited first!");
15173 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15174 return nativeResponseValue;
15176 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15178 export function ClosureReason_disconnected_peer(): number {
15179 if(!isWasmInitialized) {
15180 throw new Error("initializeWasm() must be awaited first!");
15182 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15183 return nativeResponseValue;
15185 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15187 export function ClosureReason_outdated_channel_manager(): number {
15188 if(!isWasmInitialized) {
15189 throw new Error("initializeWasm() must be awaited first!");
15191 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15192 return nativeResponseValue;
15194 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15196 export function ClosureReason_write(obj: number): number {
15197 if(!isWasmInitialized) {
15198 throw new Error("initializeWasm() must be awaited first!");
15200 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15201 return nativeResponseValue;
15203 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15205 export function ClosureReason_read(ser: number): number {
15206 if(!isWasmInitialized) {
15207 throw new Error("initializeWasm() must be awaited first!");
15209 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15210 return nativeResponseValue;
15212 // void Event_free(struct LDKEvent this_ptr);
15214 export function Event_free(this_ptr: number): void {
15215 if(!isWasmInitialized) {
15216 throw new Error("initializeWasm() must be awaited first!");
15218 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15219 // debug statements here
15221 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15223 export function Event_clone_ptr(arg: number): number {
15224 if(!isWasmInitialized) {
15225 throw new Error("initializeWasm() must be awaited first!");
15227 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15228 return nativeResponseValue;
15230 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15232 export function Event_clone(orig: number): number {
15233 if(!isWasmInitialized) {
15234 throw new Error("initializeWasm() must be awaited first!");
15236 const nativeResponseValue = wasm.TS_Event_clone(orig);
15237 return nativeResponseValue;
15239 // struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, uint64_t user_channel_id);
15241 export function Event_funding_generation_ready(temporary_channel_id: number, counterparty_node_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): number {
15242 if(!isWasmInitialized) {
15243 throw new Error("initializeWasm() must be awaited first!");
15245 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15246 return nativeResponseValue;
15248 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15250 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: number): number {
15251 if(!isWasmInitialized) {
15252 throw new Error("initializeWasm() must be awaited first!");
15254 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15255 return nativeResponseValue;
15257 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15259 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: number): number {
15260 if(!isWasmInitialized) {
15261 throw new Error("initializeWasm() must be awaited first!");
15263 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15264 return nativeResponseValue;
15266 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15268 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
15269 if(!isWasmInitialized) {
15270 throw new Error("initializeWasm() must be awaited first!");
15272 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15273 return nativeResponseValue;
15275 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15277 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
15278 if(!isWasmInitialized) {
15279 throw new Error("initializeWasm() must be awaited first!");
15281 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15282 return nativeResponseValue;
15284 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15286 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
15287 if(!isWasmInitialized) {
15288 throw new Error("initializeWasm() must be awaited first!");
15290 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15291 return nativeResponseValue;
15293 // 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);
15295 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 {
15296 if(!isWasmInitialized) {
15297 throw new Error("initializeWasm() must be awaited first!");
15299 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);
15300 return nativeResponseValue;
15302 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15304 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
15305 if(!isWasmInitialized) {
15306 throw new Error("initializeWasm() must be awaited first!");
15308 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15309 return nativeResponseValue;
15311 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15313 export function Event_spendable_outputs(outputs: number): number {
15314 if(!isWasmInitialized) {
15315 throw new Error("initializeWasm() must be awaited first!");
15317 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15318 return nativeResponseValue;
15320 // struct LDKEvent Event_payment_forwarded(struct LDKThirtyTwoBytes prev_channel_id, struct LDKThirtyTwoBytes next_channel_id, struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
15322 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
15323 if(!isWasmInitialized) {
15324 throw new Error("initializeWasm() must be awaited first!");
15326 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15327 return nativeResponseValue;
15329 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15331 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
15332 if(!isWasmInitialized) {
15333 throw new Error("initializeWasm() must be awaited first!");
15335 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15336 return nativeResponseValue;
15338 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
15340 export function Event_discard_funding(channel_id: number, transaction: number): number {
15341 if(!isWasmInitialized) {
15342 throw new Error("initializeWasm() must be awaited first!");
15344 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
15345 return nativeResponseValue;
15347 // struct LDKEvent Event_open_channel_request(struct LDKThirtyTwoBytes temporary_channel_id, struct LDKPublicKey counterparty_node_id, uint64_t funding_satoshis, uint64_t push_msat, struct LDKChannelTypeFeatures channel_type);
15349 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
15350 if(!isWasmInitialized) {
15351 throw new Error("initializeWasm() must be awaited first!");
15353 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
15354 return nativeResponseValue;
15356 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
15358 export function Event_write(obj: number): number {
15359 if(!isWasmInitialized) {
15360 throw new Error("initializeWasm() must be awaited first!");
15362 const nativeResponseValue = wasm.TS_Event_write(obj);
15363 return nativeResponseValue;
15365 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
15367 export function Event_read(ser: number): number {
15368 if(!isWasmInitialized) {
15369 throw new Error("initializeWasm() must be awaited first!");
15371 const nativeResponseValue = wasm.TS_Event_read(ser);
15372 return nativeResponseValue;
15374 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
15376 export function MessageSendEvent_free(this_ptr: number): void {
15377 if(!isWasmInitialized) {
15378 throw new Error("initializeWasm() must be awaited first!");
15380 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
15381 // debug statements here
15383 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
15385 export function MessageSendEvent_clone_ptr(arg: number): number {
15386 if(!isWasmInitialized) {
15387 throw new Error("initializeWasm() must be awaited first!");
15389 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
15390 return nativeResponseValue;
15392 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
15394 export function MessageSendEvent_clone(orig: number): number {
15395 if(!isWasmInitialized) {
15396 throw new Error("initializeWasm() must be awaited first!");
15398 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
15399 return nativeResponseValue;
15401 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
15403 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
15404 if(!isWasmInitialized) {
15405 throw new Error("initializeWasm() must be awaited first!");
15407 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
15408 return nativeResponseValue;
15410 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
15412 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
15413 if(!isWasmInitialized) {
15414 throw new Error("initializeWasm() must be awaited first!");
15416 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
15417 return nativeResponseValue;
15419 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
15421 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
15422 if(!isWasmInitialized) {
15423 throw new Error("initializeWasm() must be awaited first!");
15425 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
15426 return nativeResponseValue;
15428 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
15430 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
15431 if(!isWasmInitialized) {
15432 throw new Error("initializeWasm() must be awaited first!");
15434 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
15435 return nativeResponseValue;
15437 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
15439 export function MessageSendEvent_send_channel_ready(node_id: number, msg: number): number {
15440 if(!isWasmInitialized) {
15441 throw new Error("initializeWasm() must be awaited first!");
15443 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
15444 return nativeResponseValue;
15446 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
15448 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
15449 if(!isWasmInitialized) {
15450 throw new Error("initializeWasm() must be awaited first!");
15452 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
15453 return nativeResponseValue;
15455 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
15457 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
15458 if(!isWasmInitialized) {
15459 throw new Error("initializeWasm() must be awaited first!");
15461 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
15462 return nativeResponseValue;
15464 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
15466 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
15467 if(!isWasmInitialized) {
15468 throw new Error("initializeWasm() must be awaited first!");
15470 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
15471 return nativeResponseValue;
15473 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
15475 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
15476 if(!isWasmInitialized) {
15477 throw new Error("initializeWasm() must be awaited first!");
15479 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
15480 return nativeResponseValue;
15482 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
15484 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
15485 if(!isWasmInitialized) {
15486 throw new Error("initializeWasm() must be awaited first!");
15488 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
15489 return nativeResponseValue;
15491 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
15493 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
15494 if(!isWasmInitialized) {
15495 throw new Error("initializeWasm() must be awaited first!");
15497 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
15498 return nativeResponseValue;
15500 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
15502 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
15503 if(!isWasmInitialized) {
15504 throw new Error("initializeWasm() must be awaited first!");
15506 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
15507 return nativeResponseValue;
15509 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
15511 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
15512 if(!isWasmInitialized) {
15513 throw new Error("initializeWasm() must be awaited first!");
15515 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
15516 return nativeResponseValue;
15518 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
15520 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
15521 if(!isWasmInitialized) {
15522 throw new Error("initializeWasm() must be awaited first!");
15524 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
15525 return nativeResponseValue;
15527 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
15529 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
15530 if(!isWasmInitialized) {
15531 throw new Error("initializeWasm() must be awaited first!");
15533 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
15534 return nativeResponseValue;
15536 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
15538 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
15539 if(!isWasmInitialized) {
15540 throw new Error("initializeWasm() must be awaited first!");
15542 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
15543 return nativeResponseValue;
15545 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
15547 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
15548 if(!isWasmInitialized) {
15549 throw new Error("initializeWasm() must be awaited first!");
15551 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
15552 return nativeResponseValue;
15554 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
15556 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
15557 if(!isWasmInitialized) {
15558 throw new Error("initializeWasm() must be awaited first!");
15560 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
15561 return nativeResponseValue;
15563 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
15565 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
15566 if(!isWasmInitialized) {
15567 throw new Error("initializeWasm() must be awaited first!");
15569 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
15570 return nativeResponseValue;
15572 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
15574 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
15575 if(!isWasmInitialized) {
15576 throw new Error("initializeWasm() must be awaited first!");
15578 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
15579 return nativeResponseValue;
15581 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15583 export function MessageSendEventsProvider_free(this_ptr: number): void {
15584 if(!isWasmInitialized) {
15585 throw new Error("initializeWasm() must be awaited first!");
15587 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15588 // debug statements here
15590 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15592 export function EventsProvider_free(this_ptr: number): void {
15593 if(!isWasmInitialized) {
15594 throw new Error("initializeWasm() must be awaited first!");
15596 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15597 // debug statements here
15599 // void EventHandler_free(struct LDKEventHandler this_ptr);
15601 export function EventHandler_free(this_ptr: number): void {
15602 if(!isWasmInitialized) {
15603 throw new Error("initializeWasm() must be awaited first!");
15605 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15606 // debug statements here
15608 // void APIError_free(struct LDKAPIError this_ptr);
15610 export function APIError_free(this_ptr: number): void {
15611 if(!isWasmInitialized) {
15612 throw new Error("initializeWasm() must be awaited first!");
15614 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15615 // debug statements here
15617 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15619 export function APIError_clone_ptr(arg: number): number {
15620 if(!isWasmInitialized) {
15621 throw new Error("initializeWasm() must be awaited first!");
15623 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15624 return nativeResponseValue;
15626 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15628 export function APIError_clone(orig: number): number {
15629 if(!isWasmInitialized) {
15630 throw new Error("initializeWasm() must be awaited first!");
15632 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15633 return nativeResponseValue;
15635 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15637 export function APIError_apimisuse_error(err: number): number {
15638 if(!isWasmInitialized) {
15639 throw new Error("initializeWasm() must be awaited first!");
15641 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15642 return nativeResponseValue;
15644 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15646 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15647 if(!isWasmInitialized) {
15648 throw new Error("initializeWasm() must be awaited first!");
15650 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15651 return nativeResponseValue;
15653 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15655 export function APIError_route_error(err: number): number {
15656 if(!isWasmInitialized) {
15657 throw new Error("initializeWasm() must be awaited first!");
15659 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15660 return nativeResponseValue;
15662 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15664 export function APIError_channel_unavailable(err: number): number {
15665 if(!isWasmInitialized) {
15666 throw new Error("initializeWasm() must be awaited first!");
15668 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15669 return nativeResponseValue;
15671 // struct LDKAPIError APIError_monitor_update_failed(void);
15673 export function APIError_monitor_update_failed(): number {
15674 if(!isWasmInitialized) {
15675 throw new Error("initializeWasm() must be awaited first!");
15677 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15678 return nativeResponseValue;
15680 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15682 export function APIError_incompatible_shutdown_script(script: number): number {
15683 if(!isWasmInitialized) {
15684 throw new Error("initializeWasm() must be awaited first!");
15686 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15687 return nativeResponseValue;
15689 // void BigSize_free(struct LDKBigSize this_obj);
15691 export function BigSize_free(this_obj: number): void {
15692 if(!isWasmInitialized) {
15693 throw new Error("initializeWasm() must be awaited first!");
15695 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
15696 // debug statements here
15698 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
15700 export function BigSize_get_a(this_ptr: number): bigint {
15701 if(!isWasmInitialized) {
15702 throw new Error("initializeWasm() must be awaited first!");
15704 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
15705 return nativeResponseValue;
15707 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
15709 export function BigSize_set_a(this_ptr: number, val: bigint): void {
15710 if(!isWasmInitialized) {
15711 throw new Error("initializeWasm() must be awaited first!");
15713 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
15714 // debug statements here
15716 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
15718 export function BigSize_new(a_arg: bigint): number {
15719 if(!isWasmInitialized) {
15720 throw new Error("initializeWasm() must be awaited first!");
15722 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
15723 return nativeResponseValue;
15725 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15727 export function sign(msg: number, sk: number): number {
15728 if(!isWasmInitialized) {
15729 throw new Error("initializeWasm() must be awaited first!");
15731 const nativeResponseValue = wasm.TS_sign(msg, sk);
15732 return nativeResponseValue;
15734 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15736 export function recover_pk(msg: number, sig: number): number {
15737 if(!isWasmInitialized) {
15738 throw new Error("initializeWasm() must be awaited first!");
15740 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15741 return nativeResponseValue;
15743 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15745 export function verify(msg: number, sig: number, pk: number): boolean {
15746 if(!isWasmInitialized) {
15747 throw new Error("initializeWasm() must be awaited first!");
15749 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15750 return nativeResponseValue;
15752 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
15754 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
15755 if(!isWasmInitialized) {
15756 throw new Error("initializeWasm() must be awaited first!");
15758 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
15759 return nativeResponseValue;
15761 // void Persister_free(struct LDKPersister this_ptr);
15763 export function Persister_free(this_ptr: number): void {
15764 if(!isWasmInitialized) {
15765 throw new Error("initializeWasm() must be awaited first!");
15767 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
15768 // debug statements here
15770 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
15772 export function Level_clone(orig: number): Level {
15773 if(!isWasmInitialized) {
15774 throw new Error("initializeWasm() must be awaited first!");
15776 const nativeResponseValue = wasm.TS_Level_clone(orig);
15777 return nativeResponseValue;
15779 // enum LDKLevel Level_gossip(void);
15781 export function Level_gossip(): Level {
15782 if(!isWasmInitialized) {
15783 throw new Error("initializeWasm() must be awaited first!");
15785 const nativeResponseValue = wasm.TS_Level_gossip();
15786 return nativeResponseValue;
15788 // enum LDKLevel Level_trace(void);
15790 export function Level_trace(): Level {
15791 if(!isWasmInitialized) {
15792 throw new Error("initializeWasm() must be awaited first!");
15794 const nativeResponseValue = wasm.TS_Level_trace();
15795 return nativeResponseValue;
15797 // enum LDKLevel Level_debug(void);
15799 export function Level_debug(): Level {
15800 if(!isWasmInitialized) {
15801 throw new Error("initializeWasm() must be awaited first!");
15803 const nativeResponseValue = wasm.TS_Level_debug();
15804 return nativeResponseValue;
15806 // enum LDKLevel Level_info(void);
15808 export function Level_info(): Level {
15809 if(!isWasmInitialized) {
15810 throw new Error("initializeWasm() must be awaited first!");
15812 const nativeResponseValue = wasm.TS_Level_info();
15813 return nativeResponseValue;
15815 // enum LDKLevel Level_warn(void);
15817 export function Level_warn(): Level {
15818 if(!isWasmInitialized) {
15819 throw new Error("initializeWasm() must be awaited first!");
15821 const nativeResponseValue = wasm.TS_Level_warn();
15822 return nativeResponseValue;
15824 // enum LDKLevel Level_error(void);
15826 export function Level_error(): Level {
15827 if(!isWasmInitialized) {
15828 throw new Error("initializeWasm() must be awaited first!");
15830 const nativeResponseValue = wasm.TS_Level_error();
15831 return nativeResponseValue;
15833 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
15835 export function Level_eq(a: number, b: number): boolean {
15836 if(!isWasmInitialized) {
15837 throw new Error("initializeWasm() must be awaited first!");
15839 const nativeResponseValue = wasm.TS_Level_eq(a, b);
15840 return nativeResponseValue;
15842 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
15844 export function Level_hash(o: number): bigint {
15845 if(!isWasmInitialized) {
15846 throw new Error("initializeWasm() must be awaited first!");
15848 const nativeResponseValue = wasm.TS_Level_hash(o);
15849 return nativeResponseValue;
15851 // MUST_USE_RES enum LDKLevel Level_max(void);
15853 export function Level_max(): Level {
15854 if(!isWasmInitialized) {
15855 throw new Error("initializeWasm() must be awaited first!");
15857 const nativeResponseValue = wasm.TS_Level_max();
15858 return nativeResponseValue;
15860 // void Record_free(struct LDKRecord this_obj);
15862 export function Record_free(this_obj: number): void {
15863 if(!isWasmInitialized) {
15864 throw new Error("initializeWasm() must be awaited first!");
15866 const nativeResponseValue = wasm.TS_Record_free(this_obj);
15867 // debug statements here
15869 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
15871 export function Record_get_level(this_ptr: number): Level {
15872 if(!isWasmInitialized) {
15873 throw new Error("initializeWasm() must be awaited first!");
15875 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
15876 return nativeResponseValue;
15878 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
15880 export function Record_set_level(this_ptr: number, val: Level): void {
15881 if(!isWasmInitialized) {
15882 throw new Error("initializeWasm() must be awaited first!");
15884 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
15885 // debug statements here
15887 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
15889 export function Record_get_args(this_ptr: number): number {
15890 if(!isWasmInitialized) {
15891 throw new Error("initializeWasm() must be awaited first!");
15893 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
15894 return nativeResponseValue;
15896 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15898 export function Record_set_args(this_ptr: number, val: number): void {
15899 if(!isWasmInitialized) {
15900 throw new Error("initializeWasm() must be awaited first!");
15902 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
15903 // debug statements here
15905 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
15907 export function Record_get_module_path(this_ptr: number): number {
15908 if(!isWasmInitialized) {
15909 throw new Error("initializeWasm() must be awaited first!");
15911 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
15912 return nativeResponseValue;
15914 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15916 export function Record_set_module_path(this_ptr: number, val: number): void {
15917 if(!isWasmInitialized) {
15918 throw new Error("initializeWasm() must be awaited first!");
15920 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
15921 // debug statements here
15923 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
15925 export function Record_get_file(this_ptr: number): number {
15926 if(!isWasmInitialized) {
15927 throw new Error("initializeWasm() must be awaited first!");
15929 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
15930 return nativeResponseValue;
15932 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15934 export function Record_set_file(this_ptr: number, val: number): void {
15935 if(!isWasmInitialized) {
15936 throw new Error("initializeWasm() must be awaited first!");
15938 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
15939 // debug statements here
15941 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
15943 export function Record_get_line(this_ptr: number): number {
15944 if(!isWasmInitialized) {
15945 throw new Error("initializeWasm() must be awaited first!");
15947 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
15948 return nativeResponseValue;
15950 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
15952 export function Record_set_line(this_ptr: number, val: number): void {
15953 if(!isWasmInitialized) {
15954 throw new Error("initializeWasm() must be awaited first!");
15956 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
15957 // debug statements here
15959 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
15961 export function Record_clone_ptr(arg: number): number {
15962 if(!isWasmInitialized) {
15963 throw new Error("initializeWasm() must be awaited first!");
15965 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
15966 return nativeResponseValue;
15968 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
15970 export function Record_clone(orig: number): number {
15971 if(!isWasmInitialized) {
15972 throw new Error("initializeWasm() must be awaited first!");
15974 const nativeResponseValue = wasm.TS_Record_clone(orig);
15975 return nativeResponseValue;
15977 // void Logger_free(struct LDKLogger this_ptr);
15979 export function Logger_free(this_ptr: number): void {
15980 if(!isWasmInitialized) {
15981 throw new Error("initializeWasm() must be awaited first!");
15983 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
15984 // debug statements here
15986 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
15988 export function ChannelHandshakeConfig_free(this_obj: number): void {
15989 if(!isWasmInitialized) {
15990 throw new Error("initializeWasm() must be awaited first!");
15992 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
15993 // debug statements here
15995 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15997 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
15998 if(!isWasmInitialized) {
15999 throw new Error("initializeWasm() must be awaited first!");
16001 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16002 return nativeResponseValue;
16004 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16006 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
16007 if(!isWasmInitialized) {
16008 throw new Error("initializeWasm() must be awaited first!");
16010 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16011 // debug statements here
16013 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16015 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
16016 if(!isWasmInitialized) {
16017 throw new Error("initializeWasm() must be awaited first!");
16019 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16020 return nativeResponseValue;
16022 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16024 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
16025 if(!isWasmInitialized) {
16026 throw new Error("initializeWasm() must be awaited first!");
16028 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16029 // debug statements here
16031 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16033 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
16034 if(!isWasmInitialized) {
16035 throw new Error("initializeWasm() must be awaited first!");
16037 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16038 return nativeResponseValue;
16040 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16042 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16043 if(!isWasmInitialized) {
16044 throw new Error("initializeWasm() must be awaited first!");
16046 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16047 // debug statements here
16049 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16051 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number): number {
16052 if(!isWasmInitialized) {
16053 throw new Error("initializeWasm() must be awaited first!");
16055 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16056 return nativeResponseValue;
16058 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16060 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number, val: number): void {
16061 if(!isWasmInitialized) {
16062 throw new Error("initializeWasm() must be awaited first!");
16064 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16065 // debug statements here
16067 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16069 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
16070 if(!isWasmInitialized) {
16071 throw new Error("initializeWasm() must be awaited first!");
16073 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16074 return nativeResponseValue;
16076 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16078 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
16079 if(!isWasmInitialized) {
16080 throw new Error("initializeWasm() must be awaited first!");
16082 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16083 // debug statements here
16085 // 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, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg);
16087 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint, max_inbound_htlc_value_in_flight_percent_of_channel_arg: number, negotiate_scid_privacy_arg: boolean): number {
16088 if(!isWasmInitialized) {
16089 throw new Error("initializeWasm() must be awaited first!");
16091 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg);
16092 return nativeResponseValue;
16094 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16096 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
16097 if(!isWasmInitialized) {
16098 throw new Error("initializeWasm() must be awaited first!");
16100 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16101 return nativeResponseValue;
16103 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16105 export function ChannelHandshakeConfig_clone(orig: number): number {
16106 if(!isWasmInitialized) {
16107 throw new Error("initializeWasm() must be awaited first!");
16109 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16110 return nativeResponseValue;
16112 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16114 export function ChannelHandshakeConfig_default(): number {
16115 if(!isWasmInitialized) {
16116 throw new Error("initializeWasm() must be awaited first!");
16118 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16119 return nativeResponseValue;
16121 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16123 export function ChannelHandshakeLimits_free(this_obj: number): void {
16124 if(!isWasmInitialized) {
16125 throw new Error("initializeWasm() must be awaited first!");
16127 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16128 // debug statements here
16130 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16132 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
16133 if(!isWasmInitialized) {
16134 throw new Error("initializeWasm() must be awaited first!");
16136 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16137 return nativeResponseValue;
16139 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16141 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
16142 if(!isWasmInitialized) {
16143 throw new Error("initializeWasm() must be awaited first!");
16145 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16146 // debug statements here
16148 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16150 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: number): bigint {
16151 if(!isWasmInitialized) {
16152 throw new Error("initializeWasm() must be awaited first!");
16154 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16155 return nativeResponseValue;
16157 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16159 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: number, val: bigint): void {
16160 if(!isWasmInitialized) {
16161 throw new Error("initializeWasm() must be awaited first!");
16163 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16164 // debug statements here
16166 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16168 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
16169 if(!isWasmInitialized) {
16170 throw new Error("initializeWasm() must be awaited first!");
16172 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16173 return nativeResponseValue;
16175 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16177 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16178 if(!isWasmInitialized) {
16179 throw new Error("initializeWasm() must be awaited first!");
16181 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16182 // debug statements here
16184 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16186 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16187 if(!isWasmInitialized) {
16188 throw new Error("initializeWasm() must be awaited first!");
16190 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16191 return nativeResponseValue;
16193 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16195 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16196 if(!isWasmInitialized) {
16197 throw new Error("initializeWasm() must be awaited first!");
16199 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16200 // debug statements here
16202 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16204 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
16205 if(!isWasmInitialized) {
16206 throw new Error("initializeWasm() must be awaited first!");
16208 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16209 return nativeResponseValue;
16211 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16213 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16214 if(!isWasmInitialized) {
16215 throw new Error("initializeWasm() must be awaited first!");
16217 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16218 // debug statements here
16220 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16222 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
16223 if(!isWasmInitialized) {
16224 throw new Error("initializeWasm() must be awaited first!");
16226 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16227 return nativeResponseValue;
16229 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16231 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
16232 if(!isWasmInitialized) {
16233 throw new Error("initializeWasm() must be awaited first!");
16235 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16236 // debug statements here
16238 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16240 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
16241 if(!isWasmInitialized) {
16242 throw new Error("initializeWasm() must be awaited first!");
16244 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16245 return nativeResponseValue;
16247 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16249 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
16250 if(!isWasmInitialized) {
16251 throw new Error("initializeWasm() must be awaited first!");
16253 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16254 // debug statements here
16256 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16258 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: number): boolean {
16259 if(!isWasmInitialized) {
16260 throw new Error("initializeWasm() must be awaited first!");
16262 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
16263 return nativeResponseValue;
16265 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16267 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: number, val: boolean): void {
16268 if(!isWasmInitialized) {
16269 throw new Error("initializeWasm() must be awaited first!");
16271 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
16272 // debug statements here
16274 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16276 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
16277 if(!isWasmInitialized) {
16278 throw new Error("initializeWasm() must be awaited first!");
16280 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
16281 return nativeResponseValue;
16283 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16285 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
16286 if(!isWasmInitialized) {
16287 throw new Error("initializeWasm() must be awaited first!");
16289 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
16290 // debug statements here
16292 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16294 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
16295 if(!isWasmInitialized) {
16296 throw new Error("initializeWasm() must be awaited first!");
16298 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
16299 return nativeResponseValue;
16301 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16303 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
16304 if(!isWasmInitialized) {
16305 throw new Error("initializeWasm() must be awaited first!");
16307 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
16308 // debug statements here
16310 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_funding_satoshis_arg, uint64_t max_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 trust_own_funding_0conf_arg, bool force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
16312 export function ChannelHandshakeLimits_new(min_funding_satoshis_arg: bigint, max_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, trust_own_funding_0conf_arg: boolean, force_announced_channel_preference_arg: boolean, their_to_self_delay_arg: number): number {
16313 if(!isWasmInitialized) {
16314 throw new Error("initializeWasm() must be awaited first!");
16316 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_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, trust_own_funding_0conf_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
16317 return nativeResponseValue;
16319 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
16321 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
16322 if(!isWasmInitialized) {
16323 throw new Error("initializeWasm() must be awaited first!");
16325 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
16326 return nativeResponseValue;
16328 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
16330 export function ChannelHandshakeLimits_clone(orig: number): number {
16331 if(!isWasmInitialized) {
16332 throw new Error("initializeWasm() must be awaited first!");
16334 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
16335 return nativeResponseValue;
16337 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
16339 export function ChannelHandshakeLimits_default(): number {
16340 if(!isWasmInitialized) {
16341 throw new Error("initializeWasm() must be awaited first!");
16343 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
16344 return nativeResponseValue;
16346 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
16348 export function ChannelConfig_free(this_obj: number): void {
16349 if(!isWasmInitialized) {
16350 throw new Error("initializeWasm() must be awaited first!");
16352 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
16353 // debug statements here
16355 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16357 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
16358 if(!isWasmInitialized) {
16359 throw new Error("initializeWasm() must be awaited first!");
16361 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
16362 return nativeResponseValue;
16364 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16366 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
16367 if(!isWasmInitialized) {
16368 throw new Error("initializeWasm() must be awaited first!");
16370 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
16371 // debug statements here
16373 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16375 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
16376 if(!isWasmInitialized) {
16377 throw new Error("initializeWasm() must be awaited first!");
16379 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
16380 return nativeResponseValue;
16382 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16384 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
16385 if(!isWasmInitialized) {
16386 throw new Error("initializeWasm() must be awaited first!");
16388 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
16389 // debug statements here
16391 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16393 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
16394 if(!isWasmInitialized) {
16395 throw new Error("initializeWasm() must be awaited first!");
16397 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
16398 return nativeResponseValue;
16400 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
16402 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
16403 if(!isWasmInitialized) {
16404 throw new Error("initializeWasm() must be awaited first!");
16406 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
16407 // debug statements here
16409 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16411 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
16412 if(!isWasmInitialized) {
16413 throw new Error("initializeWasm() must be awaited first!");
16415 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
16416 return nativeResponseValue;
16418 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
16420 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
16421 if(!isWasmInitialized) {
16422 throw new Error("initializeWasm() must be awaited first!");
16424 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
16425 // debug statements here
16427 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16429 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
16430 if(!isWasmInitialized) {
16431 throw new Error("initializeWasm() must be awaited first!");
16433 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16434 return nativeResponseValue;
16436 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
16438 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
16439 if(!isWasmInitialized) {
16440 throw new Error("initializeWasm() must be awaited first!");
16442 const nativeResponseValue = wasm.TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16443 // debug statements here
16445 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16447 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
16448 if(!isWasmInitialized) {
16449 throw new Error("initializeWasm() must be awaited first!");
16451 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
16452 return nativeResponseValue;
16454 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16456 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
16457 if(!isWasmInitialized) {
16458 throw new Error("initializeWasm() must be awaited first!");
16460 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
16461 // debug statements here
16463 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16465 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
16466 if(!isWasmInitialized) {
16467 throw new Error("initializeWasm() must be awaited first!");
16469 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
16470 return nativeResponseValue;
16472 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16474 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
16475 if(!isWasmInitialized) {
16476 throw new Error("initializeWasm() must be awaited first!");
16478 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
16479 // debug statements here
16481 // 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);
16483 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 {
16484 if(!isWasmInitialized) {
16485 throw new Error("initializeWasm() must be awaited first!");
16487 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);
16488 return nativeResponseValue;
16490 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
16492 export function ChannelConfig_clone_ptr(arg: number): number {
16493 if(!isWasmInitialized) {
16494 throw new Error("initializeWasm() must be awaited first!");
16496 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
16497 return nativeResponseValue;
16499 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
16501 export function ChannelConfig_clone(orig: number): number {
16502 if(!isWasmInitialized) {
16503 throw new Error("initializeWasm() must be awaited first!");
16505 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
16506 return nativeResponseValue;
16508 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
16510 export function ChannelConfig_default(): number {
16511 if(!isWasmInitialized) {
16512 throw new Error("initializeWasm() must be awaited first!");
16514 const nativeResponseValue = wasm.TS_ChannelConfig_default();
16515 return nativeResponseValue;
16517 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
16519 export function ChannelConfig_write(obj: number): number {
16520 if(!isWasmInitialized) {
16521 throw new Error("initializeWasm() must be awaited first!");
16523 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
16524 return nativeResponseValue;
16526 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
16528 export function ChannelConfig_read(ser: number): number {
16529 if(!isWasmInitialized) {
16530 throw new Error("initializeWasm() must be awaited first!");
16532 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
16533 return nativeResponseValue;
16535 // void UserConfig_free(struct LDKUserConfig this_obj);
16537 export function UserConfig_free(this_obj: number): void {
16538 if(!isWasmInitialized) {
16539 throw new Error("initializeWasm() must be awaited first!");
16541 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
16542 // debug statements here
16544 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16546 export function UserConfig_get_own_channel_config(this_ptr: number): number {
16547 if(!isWasmInitialized) {
16548 throw new Error("initializeWasm() must be awaited first!");
16550 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
16551 return nativeResponseValue;
16553 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
16555 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
16556 if(!isWasmInitialized) {
16557 throw new Error("initializeWasm() must be awaited first!");
16559 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
16560 // debug statements here
16562 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16564 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
16565 if(!isWasmInitialized) {
16566 throw new Error("initializeWasm() must be awaited first!");
16568 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
16569 return nativeResponseValue;
16571 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
16573 export function UserConfig_set_peer_channel_config_limits(this_ptr: number, val: number): void {
16574 if(!isWasmInitialized) {
16575 throw new Error("initializeWasm() must be awaited first!");
16577 const nativeResponseValue = wasm.TS_UserConfig_set_peer_channel_config_limits(this_ptr, val);
16578 // debug statements here
16580 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16582 export function UserConfig_get_channel_options(this_ptr: number): number {
16583 if(!isWasmInitialized) {
16584 throw new Error("initializeWasm() must be awaited first!");
16586 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
16587 return nativeResponseValue;
16589 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
16591 export function UserConfig_set_channel_options(this_ptr: number, val: number): void {
16592 if(!isWasmInitialized) {
16593 throw new Error("initializeWasm() must be awaited first!");
16595 const nativeResponseValue = wasm.TS_UserConfig_set_channel_options(this_ptr, val);
16596 // debug statements here
16598 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16600 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
16601 if(!isWasmInitialized) {
16602 throw new Error("initializeWasm() must be awaited first!");
16604 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
16605 return nativeResponseValue;
16607 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16609 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
16610 if(!isWasmInitialized) {
16611 throw new Error("initializeWasm() must be awaited first!");
16613 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
16614 // debug statements here
16616 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16618 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
16619 if(!isWasmInitialized) {
16620 throw new Error("initializeWasm() must be awaited first!");
16622 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
16623 return nativeResponseValue;
16625 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16627 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
16628 if(!isWasmInitialized) {
16629 throw new Error("initializeWasm() must be awaited first!");
16631 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
16632 // debug statements here
16634 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16636 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
16637 if(!isWasmInitialized) {
16638 throw new Error("initializeWasm() must be awaited first!");
16640 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
16641 return nativeResponseValue;
16643 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16645 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
16646 if(!isWasmInitialized) {
16647 throw new Error("initializeWasm() must be awaited first!");
16649 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
16650 // debug statements here
16652 // 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, bool manually_accept_inbound_channels_arg);
16654 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, manually_accept_inbound_channels_arg: boolean): number {
16655 if(!isWasmInitialized) {
16656 throw new Error("initializeWasm() must be awaited first!");
16658 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, manually_accept_inbound_channels_arg);
16659 return nativeResponseValue;
16661 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
16663 export function UserConfig_clone_ptr(arg: number): number {
16664 if(!isWasmInitialized) {
16665 throw new Error("initializeWasm() must be awaited first!");
16667 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
16668 return nativeResponseValue;
16670 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
16672 export function UserConfig_clone(orig: number): number {
16673 if(!isWasmInitialized) {
16674 throw new Error("initializeWasm() must be awaited first!");
16676 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
16677 return nativeResponseValue;
16679 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
16681 export function UserConfig_default(): number {
16682 if(!isWasmInitialized) {
16683 throw new Error("initializeWasm() must be awaited first!");
16685 const nativeResponseValue = wasm.TS_UserConfig_default();
16686 return nativeResponseValue;
16688 // void BestBlock_free(struct LDKBestBlock this_obj);
16690 export function BestBlock_free(this_obj: number): void {
16691 if(!isWasmInitialized) {
16692 throw new Error("initializeWasm() must be awaited first!");
16694 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
16695 // debug statements here
16697 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16699 export function BestBlock_clone_ptr(arg: number): number {
16700 if(!isWasmInitialized) {
16701 throw new Error("initializeWasm() must be awaited first!");
16703 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16704 return nativeResponseValue;
16706 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16708 export function BestBlock_clone(orig: number): number {
16709 if(!isWasmInitialized) {
16710 throw new Error("initializeWasm() must be awaited first!");
16712 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16713 return nativeResponseValue;
16715 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16717 export function BestBlock_from_genesis(network: Network): number {
16718 if(!isWasmInitialized) {
16719 throw new Error("initializeWasm() must be awaited first!");
16721 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16722 return nativeResponseValue;
16724 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16726 export function BestBlock_new(block_hash: number, height: number): number {
16727 if(!isWasmInitialized) {
16728 throw new Error("initializeWasm() must be awaited first!");
16730 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16731 return nativeResponseValue;
16733 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16735 export function BestBlock_block_hash(this_arg: number): number {
16736 if(!isWasmInitialized) {
16737 throw new Error("initializeWasm() must be awaited first!");
16739 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16740 return nativeResponseValue;
16742 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16744 export function BestBlock_height(this_arg: number): number {
16745 if(!isWasmInitialized) {
16746 throw new Error("initializeWasm() must be awaited first!");
16748 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16749 return nativeResponseValue;
16751 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16753 export function AccessError_clone(orig: number): AccessError {
16754 if(!isWasmInitialized) {
16755 throw new Error("initializeWasm() must be awaited first!");
16757 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
16758 return nativeResponseValue;
16760 // enum LDKAccessError AccessError_unknown_chain(void);
16762 export function AccessError_unknown_chain(): AccessError {
16763 if(!isWasmInitialized) {
16764 throw new Error("initializeWasm() must be awaited first!");
16766 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
16767 return nativeResponseValue;
16769 // enum LDKAccessError AccessError_unknown_tx(void);
16771 export function AccessError_unknown_tx(): AccessError {
16772 if(!isWasmInitialized) {
16773 throw new Error("initializeWasm() must be awaited first!");
16775 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
16776 return nativeResponseValue;
16778 // void Access_free(struct LDKAccess this_ptr);
16780 export function Access_free(this_ptr: number): void {
16781 if(!isWasmInitialized) {
16782 throw new Error("initializeWasm() must be awaited first!");
16784 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
16785 // debug statements here
16787 // void Listen_free(struct LDKListen this_ptr);
16789 export function Listen_free(this_ptr: number): void {
16790 if(!isWasmInitialized) {
16791 throw new Error("initializeWasm() must be awaited first!");
16793 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
16794 // debug statements here
16796 // void Confirm_free(struct LDKConfirm this_ptr);
16798 export function Confirm_free(this_ptr: number): void {
16799 if(!isWasmInitialized) {
16800 throw new Error("initializeWasm() must be awaited first!");
16802 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
16803 // debug statements here
16805 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
16807 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
16808 if(!isWasmInitialized) {
16809 throw new Error("initializeWasm() must be awaited first!");
16811 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
16812 return nativeResponseValue;
16814 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
16816 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
16817 if(!isWasmInitialized) {
16818 throw new Error("initializeWasm() must be awaited first!");
16820 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
16821 return nativeResponseValue;
16823 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
16825 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
16826 if(!isWasmInitialized) {
16827 throw new Error("initializeWasm() must be awaited first!");
16829 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
16830 return nativeResponseValue;
16832 // void Watch_free(struct LDKWatch this_ptr);
16834 export function Watch_free(this_ptr: number): void {
16835 if(!isWasmInitialized) {
16836 throw new Error("initializeWasm() must be awaited first!");
16838 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
16839 // debug statements here
16841 // void Filter_free(struct LDKFilter this_ptr);
16843 export function Filter_free(this_ptr: number): void {
16844 if(!isWasmInitialized) {
16845 throw new Error("initializeWasm() must be awaited first!");
16847 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
16848 // debug statements here
16850 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
16852 export function WatchedOutput_free(this_obj: number): void {
16853 if(!isWasmInitialized) {
16854 throw new Error("initializeWasm() must be awaited first!");
16856 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
16857 // debug statements here
16859 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16861 export function WatchedOutput_get_block_hash(this_ptr: number): number {
16862 if(!isWasmInitialized) {
16863 throw new Error("initializeWasm() must be awaited first!");
16865 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
16866 return nativeResponseValue;
16868 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16870 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
16871 if(!isWasmInitialized) {
16872 throw new Error("initializeWasm() must be awaited first!");
16874 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
16875 // debug statements here
16877 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16879 export function WatchedOutput_get_outpoint(this_ptr: number): number {
16880 if(!isWasmInitialized) {
16881 throw new Error("initializeWasm() must be awaited first!");
16883 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
16884 return nativeResponseValue;
16886 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
16888 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
16889 if(!isWasmInitialized) {
16890 throw new Error("initializeWasm() must be awaited first!");
16892 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
16893 // debug statements here
16895 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16897 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
16898 if(!isWasmInitialized) {
16899 throw new Error("initializeWasm() must be awaited first!");
16901 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
16902 return nativeResponseValue;
16904 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
16906 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
16907 if(!isWasmInitialized) {
16908 throw new Error("initializeWasm() must be awaited first!");
16910 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
16911 // debug statements here
16913 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
16915 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
16916 if(!isWasmInitialized) {
16917 throw new Error("initializeWasm() must be awaited first!");
16919 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
16920 return nativeResponseValue;
16922 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
16924 export function WatchedOutput_clone_ptr(arg: number): number {
16925 if(!isWasmInitialized) {
16926 throw new Error("initializeWasm() must be awaited first!");
16928 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
16929 return nativeResponseValue;
16931 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
16933 export function WatchedOutput_clone(orig: number): number {
16934 if(!isWasmInitialized) {
16935 throw new Error("initializeWasm() must be awaited first!");
16937 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
16938 return nativeResponseValue;
16940 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
16942 export function WatchedOutput_hash(o: number): bigint {
16943 if(!isWasmInitialized) {
16944 throw new Error("initializeWasm() must be awaited first!");
16946 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
16947 return nativeResponseValue;
16949 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
16951 export function BroadcasterInterface_free(this_ptr: number): void {
16952 if(!isWasmInitialized) {
16953 throw new Error("initializeWasm() must be awaited first!");
16955 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
16956 // debug statements here
16958 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
16960 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
16961 if(!isWasmInitialized) {
16962 throw new Error("initializeWasm() must be awaited first!");
16964 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
16965 return nativeResponseValue;
16967 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
16969 export function ConfirmationTarget_background(): ConfirmationTarget {
16970 if(!isWasmInitialized) {
16971 throw new Error("initializeWasm() must be awaited first!");
16973 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
16974 return nativeResponseValue;
16976 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
16978 export function ConfirmationTarget_normal(): ConfirmationTarget {
16979 if(!isWasmInitialized) {
16980 throw new Error("initializeWasm() must be awaited first!");
16982 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
16983 return nativeResponseValue;
16985 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
16987 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
16988 if(!isWasmInitialized) {
16989 throw new Error("initializeWasm() must be awaited first!");
16991 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
16992 return nativeResponseValue;
16994 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
16996 export function ConfirmationTarget_eq(a: number, b: number): boolean {
16997 if(!isWasmInitialized) {
16998 throw new Error("initializeWasm() must be awaited first!");
17000 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
17001 return nativeResponseValue;
17003 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17005 export function FeeEstimator_free(this_ptr: number): void {
17006 if(!isWasmInitialized) {
17007 throw new Error("initializeWasm() must be awaited first!");
17009 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17010 // debug statements here
17012 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17014 export function MonitorUpdateId_free(this_obj: number): void {
17015 if(!isWasmInitialized) {
17016 throw new Error("initializeWasm() must be awaited first!");
17018 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17019 // debug statements here
17021 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17023 export function MonitorUpdateId_clone_ptr(arg: number): number {
17024 if(!isWasmInitialized) {
17025 throw new Error("initializeWasm() must be awaited first!");
17027 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17028 return nativeResponseValue;
17030 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17032 export function MonitorUpdateId_clone(orig: number): number {
17033 if(!isWasmInitialized) {
17034 throw new Error("initializeWasm() must be awaited first!");
17036 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17037 return nativeResponseValue;
17039 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17041 export function MonitorUpdateId_hash(o: number): bigint {
17042 if(!isWasmInitialized) {
17043 throw new Error("initializeWasm() must be awaited first!");
17045 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17046 return nativeResponseValue;
17048 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17050 export function MonitorUpdateId_eq(a: number, b: number): boolean {
17051 if(!isWasmInitialized) {
17052 throw new Error("initializeWasm() must be awaited first!");
17054 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17055 return nativeResponseValue;
17057 // void Persist_free(struct LDKPersist this_ptr);
17059 export function Persist_free(this_ptr: number): void {
17060 if(!isWasmInitialized) {
17061 throw new Error("initializeWasm() must be awaited first!");
17063 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17064 // debug statements here
17066 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17068 export function LockedChannelMonitor_free(this_obj: number): void {
17069 if(!isWasmInitialized) {
17070 throw new Error("initializeWasm() must be awaited first!");
17072 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17073 // debug statements here
17075 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17077 export function ChainMonitor_free(this_obj: number): void {
17078 if(!isWasmInitialized) {
17079 throw new Error("initializeWasm() must be awaited first!");
17081 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17082 // debug statements here
17084 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17086 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
17087 if(!isWasmInitialized) {
17088 throw new Error("initializeWasm() must be awaited first!");
17090 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17091 return nativeResponseValue;
17093 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17095 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
17096 if(!isWasmInitialized) {
17097 throw new Error("initializeWasm() must be awaited first!");
17099 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17100 return nativeResponseValue;
17102 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17104 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
17105 if(!isWasmInitialized) {
17106 throw new Error("initializeWasm() must be awaited first!");
17108 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17109 return nativeResponseValue;
17111 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17113 export function ChainMonitor_list_monitors(this_arg: number): number {
17114 if(!isWasmInitialized) {
17115 throw new Error("initializeWasm() must be awaited first!");
17117 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17118 return nativeResponseValue;
17120 // 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);
17122 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
17123 if(!isWasmInitialized) {
17124 throw new Error("initializeWasm() must be awaited first!");
17126 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17127 return nativeResponseValue;
17129 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17131 export function ChainMonitor_as_Listen(this_arg: number): number {
17132 if(!isWasmInitialized) {
17133 throw new Error("initializeWasm() must be awaited first!");
17135 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17136 return nativeResponseValue;
17138 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17140 export function ChainMonitor_as_Confirm(this_arg: number): number {
17141 if(!isWasmInitialized) {
17142 throw new Error("initializeWasm() must be awaited first!");
17144 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17145 return nativeResponseValue;
17147 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17149 export function ChainMonitor_as_Watch(this_arg: number): number {
17150 if(!isWasmInitialized) {
17151 throw new Error("initializeWasm() must be awaited first!");
17153 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17154 return nativeResponseValue;
17156 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17158 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
17159 if(!isWasmInitialized) {
17160 throw new Error("initializeWasm() must be awaited first!");
17162 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17163 return nativeResponseValue;
17165 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17167 export function ChannelMonitorUpdate_free(this_obj: number): void {
17168 if(!isWasmInitialized) {
17169 throw new Error("initializeWasm() must be awaited first!");
17171 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17172 // debug statements here
17174 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17176 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
17177 if(!isWasmInitialized) {
17178 throw new Error("initializeWasm() must be awaited first!");
17180 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17181 return nativeResponseValue;
17183 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17185 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
17186 if(!isWasmInitialized) {
17187 throw new Error("initializeWasm() must be awaited first!");
17189 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17190 // debug statements here
17192 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17194 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
17195 if(!isWasmInitialized) {
17196 throw new Error("initializeWasm() must be awaited first!");
17198 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17199 return nativeResponseValue;
17201 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17203 export function ChannelMonitorUpdate_clone(orig: number): number {
17204 if(!isWasmInitialized) {
17205 throw new Error("initializeWasm() must be awaited first!");
17207 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17208 return nativeResponseValue;
17210 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17212 export function ChannelMonitorUpdate_write(obj: number): number {
17213 if(!isWasmInitialized) {
17214 throw new Error("initializeWasm() must be awaited first!");
17216 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17217 return nativeResponseValue;
17219 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17221 export function ChannelMonitorUpdate_read(ser: number): number {
17222 if(!isWasmInitialized) {
17223 throw new Error("initializeWasm() must be awaited first!");
17225 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17226 return nativeResponseValue;
17228 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17230 export function MonitorEvent_free(this_ptr: number): void {
17231 if(!isWasmInitialized) {
17232 throw new Error("initializeWasm() must be awaited first!");
17234 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17235 // debug statements here
17237 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17239 export function MonitorEvent_clone_ptr(arg: number): number {
17240 if(!isWasmInitialized) {
17241 throw new Error("initializeWasm() must be awaited first!");
17243 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17244 return nativeResponseValue;
17246 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17248 export function MonitorEvent_clone(orig: number): number {
17249 if(!isWasmInitialized) {
17250 throw new Error("initializeWasm() must be awaited first!");
17252 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17253 return nativeResponseValue;
17255 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17257 export function MonitorEvent_htlcevent(a: number): number {
17258 if(!isWasmInitialized) {
17259 throw new Error("initializeWasm() must be awaited first!");
17261 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17262 return nativeResponseValue;
17264 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17266 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
17267 if(!isWasmInitialized) {
17268 throw new Error("initializeWasm() must be awaited first!");
17270 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17271 return nativeResponseValue;
17273 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17275 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
17276 if(!isWasmInitialized) {
17277 throw new Error("initializeWasm() must be awaited first!");
17279 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17280 return nativeResponseValue;
17282 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17284 export function MonitorEvent_update_failed(a: number): number {
17285 if(!isWasmInitialized) {
17286 throw new Error("initializeWasm() must be awaited first!");
17288 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17289 return nativeResponseValue;
17291 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
17293 export function MonitorEvent_write(obj: number): number {
17294 if(!isWasmInitialized) {
17295 throw new Error("initializeWasm() must be awaited first!");
17297 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
17298 return nativeResponseValue;
17300 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
17302 export function MonitorEvent_read(ser: number): number {
17303 if(!isWasmInitialized) {
17304 throw new Error("initializeWasm() must be awaited first!");
17306 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
17307 return nativeResponseValue;
17309 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
17311 export function HTLCUpdate_free(this_obj: number): void {
17312 if(!isWasmInitialized) {
17313 throw new Error("initializeWasm() must be awaited first!");
17315 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
17316 // debug statements here
17318 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
17320 export function HTLCUpdate_clone_ptr(arg: number): number {
17321 if(!isWasmInitialized) {
17322 throw new Error("initializeWasm() must be awaited first!");
17324 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
17325 return nativeResponseValue;
17327 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
17329 export function HTLCUpdate_clone(orig: number): number {
17330 if(!isWasmInitialized) {
17331 throw new Error("initializeWasm() must be awaited first!");
17333 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
17334 return nativeResponseValue;
17336 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
17338 export function HTLCUpdate_write(obj: number): number {
17339 if(!isWasmInitialized) {
17340 throw new Error("initializeWasm() must be awaited first!");
17342 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
17343 return nativeResponseValue;
17345 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
17347 export function HTLCUpdate_read(ser: number): number {
17348 if(!isWasmInitialized) {
17349 throw new Error("initializeWasm() must be awaited first!");
17351 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
17352 return nativeResponseValue;
17354 // void Balance_free(struct LDKBalance this_ptr);
17356 export function Balance_free(this_ptr: number): void {
17357 if(!isWasmInitialized) {
17358 throw new Error("initializeWasm() must be awaited first!");
17360 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
17361 // debug statements here
17363 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
17365 export function Balance_clone_ptr(arg: number): number {
17366 if(!isWasmInitialized) {
17367 throw new Error("initializeWasm() must be awaited first!");
17369 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
17370 return nativeResponseValue;
17372 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
17374 export function Balance_clone(orig: number): number {
17375 if(!isWasmInitialized) {
17376 throw new Error("initializeWasm() must be awaited first!");
17378 const nativeResponseValue = wasm.TS_Balance_clone(orig);
17379 return nativeResponseValue;
17381 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
17383 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
17384 if(!isWasmInitialized) {
17385 throw new Error("initializeWasm() must be awaited first!");
17387 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
17388 return nativeResponseValue;
17390 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
17392 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
17393 if(!isWasmInitialized) {
17394 throw new Error("initializeWasm() must be awaited first!");
17396 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
17397 return nativeResponseValue;
17399 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
17401 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
17402 if(!isWasmInitialized) {
17403 throw new Error("initializeWasm() must be awaited first!");
17405 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
17406 return nativeResponseValue;
17408 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
17410 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
17411 if(!isWasmInitialized) {
17412 throw new Error("initializeWasm() must be awaited first!");
17414 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
17415 return nativeResponseValue;
17417 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
17419 export function Balance_eq(a: number, b: number): boolean {
17420 if(!isWasmInitialized) {
17421 throw new Error("initializeWasm() must be awaited first!");
17423 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
17424 return nativeResponseValue;
17426 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
17428 export function ChannelMonitor_free(this_obj: number): void {
17429 if(!isWasmInitialized) {
17430 throw new Error("initializeWasm() must be awaited first!");
17432 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
17433 // debug statements here
17435 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
17437 export function ChannelMonitor_clone_ptr(arg: number): number {
17438 if(!isWasmInitialized) {
17439 throw new Error("initializeWasm() must be awaited first!");
17441 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
17442 return nativeResponseValue;
17444 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
17446 export function ChannelMonitor_clone(orig: number): number {
17447 if(!isWasmInitialized) {
17448 throw new Error("initializeWasm() must be awaited first!");
17450 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
17451 return nativeResponseValue;
17453 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
17455 export function ChannelMonitor_write(obj: number): number {
17456 if(!isWasmInitialized) {
17457 throw new Error("initializeWasm() must be awaited first!");
17459 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
17460 return nativeResponseValue;
17462 // 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);
17464 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
17465 if(!isWasmInitialized) {
17466 throw new Error("initializeWasm() must be awaited first!");
17468 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
17469 return nativeResponseValue;
17471 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17473 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
17474 if(!isWasmInitialized) {
17475 throw new Error("initializeWasm() must be awaited first!");
17477 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
17478 return nativeResponseValue;
17480 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17482 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
17483 if(!isWasmInitialized) {
17484 throw new Error("initializeWasm() must be awaited first!");
17486 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
17487 return nativeResponseValue;
17489 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17491 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
17492 if(!isWasmInitialized) {
17493 throw new Error("initializeWasm() must be awaited first!");
17495 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
17496 return nativeResponseValue;
17498 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
17500 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
17501 if(!isWasmInitialized) {
17502 throw new Error("initializeWasm() must be awaited first!");
17504 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
17505 // debug statements here
17507 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17509 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
17510 if(!isWasmInitialized) {
17511 throw new Error("initializeWasm() must be awaited first!");
17513 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
17514 return nativeResponseValue;
17516 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17518 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
17519 if(!isWasmInitialized) {
17520 throw new Error("initializeWasm() must be awaited first!");
17522 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
17523 return nativeResponseValue;
17525 // 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);
17527 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
17528 if(!isWasmInitialized) {
17529 throw new Error("initializeWasm() must be awaited first!");
17531 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
17532 return nativeResponseValue;
17534 // 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);
17536 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17537 if(!isWasmInitialized) {
17538 throw new Error("initializeWasm() must be awaited first!");
17540 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17541 return nativeResponseValue;
17543 // 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);
17545 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
17546 if(!isWasmInitialized) {
17547 throw new Error("initializeWasm() must be awaited first!");
17549 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
17550 // debug statements here
17552 // 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);
17554 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17555 if(!isWasmInitialized) {
17556 throw new Error("initializeWasm() must be awaited first!");
17558 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17559 return nativeResponseValue;
17561 // 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);
17563 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
17564 if(!isWasmInitialized) {
17565 throw new Error("initializeWasm() must be awaited first!");
17567 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
17568 // debug statements here
17570 // 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);
17572 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17573 if(!isWasmInitialized) {
17574 throw new Error("initializeWasm() must be awaited first!");
17576 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
17577 return nativeResponseValue;
17579 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17581 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
17582 if(!isWasmInitialized) {
17583 throw new Error("initializeWasm() must be awaited first!");
17585 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
17586 return nativeResponseValue;
17588 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17590 export function ChannelMonitor_current_best_block(this_arg: number): number {
17591 if(!isWasmInitialized) {
17592 throw new Error("initializeWasm() must be awaited first!");
17594 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
17595 return nativeResponseValue;
17597 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17599 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
17600 if(!isWasmInitialized) {
17601 throw new Error("initializeWasm() must be awaited first!");
17603 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
17604 return nativeResponseValue;
17606 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
17608 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
17609 if(!isWasmInitialized) {
17610 throw new Error("initializeWasm() must be awaited first!");
17612 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
17613 return nativeResponseValue;
17615 // void OutPoint_free(struct LDKOutPoint this_obj);
17617 export function OutPoint_free(this_obj: number): void {
17618 if(!isWasmInitialized) {
17619 throw new Error("initializeWasm() must be awaited first!");
17621 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
17622 // debug statements here
17624 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
17626 export function OutPoint_get_txid(this_ptr: number): number {
17627 if(!isWasmInitialized) {
17628 throw new Error("initializeWasm() must be awaited first!");
17630 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
17631 return nativeResponseValue;
17633 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17635 export function OutPoint_set_txid(this_ptr: number, val: number): void {
17636 if(!isWasmInitialized) {
17637 throw new Error("initializeWasm() must be awaited first!");
17639 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
17640 // debug statements here
17642 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
17644 export function OutPoint_get_index(this_ptr: number): number {
17645 if(!isWasmInitialized) {
17646 throw new Error("initializeWasm() must be awaited first!");
17648 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
17649 return nativeResponseValue;
17651 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
17653 export function OutPoint_set_index(this_ptr: number, val: number): void {
17654 if(!isWasmInitialized) {
17655 throw new Error("initializeWasm() must be awaited first!");
17657 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
17658 // debug statements here
17660 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
17662 export function OutPoint_new(txid_arg: number, index_arg: number): number {
17663 if(!isWasmInitialized) {
17664 throw new Error("initializeWasm() must be awaited first!");
17666 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
17667 return nativeResponseValue;
17669 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
17671 export function OutPoint_clone_ptr(arg: number): number {
17672 if(!isWasmInitialized) {
17673 throw new Error("initializeWasm() must be awaited first!");
17675 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
17676 return nativeResponseValue;
17678 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
17680 export function OutPoint_clone(orig: number): number {
17681 if(!isWasmInitialized) {
17682 throw new Error("initializeWasm() must be awaited first!");
17684 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
17685 return nativeResponseValue;
17687 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
17689 export function OutPoint_eq(a: number, b: number): boolean {
17690 if(!isWasmInitialized) {
17691 throw new Error("initializeWasm() must be awaited first!");
17693 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
17694 return nativeResponseValue;
17696 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17698 export function OutPoint_hash(o: number): bigint {
17699 if(!isWasmInitialized) {
17700 throw new Error("initializeWasm() must be awaited first!");
17702 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17703 return nativeResponseValue;
17705 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17707 export function OutPoint_to_channel_id(this_arg: number): number {
17708 if(!isWasmInitialized) {
17709 throw new Error("initializeWasm() must be awaited first!");
17711 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17712 return nativeResponseValue;
17714 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17716 export function OutPoint_write(obj: number): number {
17717 if(!isWasmInitialized) {
17718 throw new Error("initializeWasm() must be awaited first!");
17720 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17721 return nativeResponseValue;
17723 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17725 export function OutPoint_read(ser: number): number {
17726 if(!isWasmInitialized) {
17727 throw new Error("initializeWasm() must be awaited first!");
17729 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17730 return nativeResponseValue;
17732 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17734 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17735 if(!isWasmInitialized) {
17736 throw new Error("initializeWasm() must be awaited first!");
17738 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17739 // debug statements here
17741 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17743 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17744 if(!isWasmInitialized) {
17745 throw new Error("initializeWasm() must be awaited first!");
17747 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17748 return nativeResponseValue;
17750 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17752 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17753 if(!isWasmInitialized) {
17754 throw new Error("initializeWasm() must be awaited first!");
17756 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17757 // debug statements here
17759 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17761 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
17762 if(!isWasmInitialized) {
17763 throw new Error("initializeWasm() must be awaited first!");
17765 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
17766 return nativeResponseValue;
17768 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17770 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
17771 if(!isWasmInitialized) {
17772 throw new Error("initializeWasm() must be awaited first!");
17774 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
17775 // debug statements here
17777 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17779 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
17780 if(!isWasmInitialized) {
17781 throw new Error("initializeWasm() must be awaited first!");
17783 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
17784 return nativeResponseValue;
17786 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
17788 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
17789 if(!isWasmInitialized) {
17790 throw new Error("initializeWasm() must be awaited first!");
17792 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
17793 // debug statements here
17795 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17797 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17798 if(!isWasmInitialized) {
17799 throw new Error("initializeWasm() must be awaited first!");
17801 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
17802 // debug statements here
17804 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17806 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
17807 if(!isWasmInitialized) {
17808 throw new Error("initializeWasm() must be awaited first!");
17810 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
17811 return nativeResponseValue;
17813 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17815 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
17816 if(!isWasmInitialized) {
17817 throw new Error("initializeWasm() must be awaited first!");
17819 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
17820 // debug statements here
17822 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17824 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17825 if(!isWasmInitialized) {
17826 throw new Error("initializeWasm() must be awaited first!");
17828 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17829 return nativeResponseValue;
17831 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17833 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17834 if(!isWasmInitialized) {
17835 throw new Error("initializeWasm() must be awaited first!");
17837 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17838 // debug statements here
17840 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17842 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17843 if(!isWasmInitialized) {
17844 throw new Error("initializeWasm() must be awaited first!");
17846 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17847 return nativeResponseValue;
17849 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17851 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17852 if(!isWasmInitialized) {
17853 throw new Error("initializeWasm() must be awaited first!");
17855 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17856 // debug statements here
17858 // 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);
17860 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 {
17861 if(!isWasmInitialized) {
17862 throw new Error("initializeWasm() must be awaited first!");
17864 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);
17865 return nativeResponseValue;
17867 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
17869 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
17870 if(!isWasmInitialized) {
17871 throw new Error("initializeWasm() must be awaited first!");
17873 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
17874 return nativeResponseValue;
17876 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
17878 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
17879 if(!isWasmInitialized) {
17880 throw new Error("initializeWasm() must be awaited first!");
17882 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
17883 return nativeResponseValue;
17885 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
17887 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
17888 if(!isWasmInitialized) {
17889 throw new Error("initializeWasm() must be awaited first!");
17891 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
17892 return nativeResponseValue;
17894 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
17896 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
17897 if(!isWasmInitialized) {
17898 throw new Error("initializeWasm() must be awaited first!");
17900 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
17901 return nativeResponseValue;
17903 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
17905 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
17906 if(!isWasmInitialized) {
17907 throw new Error("initializeWasm() must be awaited first!");
17909 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
17910 // debug statements here
17912 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17914 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17915 if(!isWasmInitialized) {
17916 throw new Error("initializeWasm() must be awaited first!");
17918 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
17919 return nativeResponseValue;
17921 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17923 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17924 if(!isWasmInitialized) {
17925 throw new Error("initializeWasm() must be awaited first!");
17927 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17928 // debug statements here
17930 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17932 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17933 if(!isWasmInitialized) {
17934 throw new Error("initializeWasm() must be awaited first!");
17936 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
17937 // debug statements here
17939 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17941 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17942 if(!isWasmInitialized) {
17943 throw new Error("initializeWasm() must be awaited first!");
17945 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17946 return nativeResponseValue;
17948 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17950 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17951 if(!isWasmInitialized) {
17952 throw new Error("initializeWasm() must be awaited first!");
17954 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17955 // debug statements here
17957 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17959 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17960 if(!isWasmInitialized) {
17961 throw new Error("initializeWasm() must be awaited first!");
17963 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17964 return nativeResponseValue;
17966 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17968 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17969 if(!isWasmInitialized) {
17970 throw new Error("initializeWasm() must be awaited first!");
17972 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17973 // debug statements here
17975 // 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);
17977 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
17978 if(!isWasmInitialized) {
17979 throw new Error("initializeWasm() must be awaited first!");
17981 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
17982 return nativeResponseValue;
17984 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
17986 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
17987 if(!isWasmInitialized) {
17988 throw new Error("initializeWasm() must be awaited first!");
17990 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
17991 return nativeResponseValue;
17993 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
17995 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
17996 if(!isWasmInitialized) {
17997 throw new Error("initializeWasm() must be awaited first!");
17999 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
18000 return nativeResponseValue;
18002 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18004 export function StaticPaymentOutputDescriptor_write(obj: number): number {
18005 if(!isWasmInitialized) {
18006 throw new Error("initializeWasm() must be awaited first!");
18008 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18009 return nativeResponseValue;
18011 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18013 export function StaticPaymentOutputDescriptor_read(ser: number): number {
18014 if(!isWasmInitialized) {
18015 throw new Error("initializeWasm() must be awaited first!");
18017 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18018 return nativeResponseValue;
18020 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18022 export function SpendableOutputDescriptor_free(this_ptr: number): void {
18023 if(!isWasmInitialized) {
18024 throw new Error("initializeWasm() must be awaited first!");
18026 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18027 // debug statements here
18029 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18031 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
18032 if(!isWasmInitialized) {
18033 throw new Error("initializeWasm() must be awaited first!");
18035 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18036 return nativeResponseValue;
18038 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18040 export function SpendableOutputDescriptor_clone(orig: number): number {
18041 if(!isWasmInitialized) {
18042 throw new Error("initializeWasm() must be awaited first!");
18044 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18045 return nativeResponseValue;
18047 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18049 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
18050 if(!isWasmInitialized) {
18051 throw new Error("initializeWasm() must be awaited first!");
18053 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18054 return nativeResponseValue;
18056 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18058 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
18059 if(!isWasmInitialized) {
18060 throw new Error("initializeWasm() must be awaited first!");
18062 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18063 return nativeResponseValue;
18065 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18067 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
18068 if(!isWasmInitialized) {
18069 throw new Error("initializeWasm() must be awaited first!");
18071 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18072 return nativeResponseValue;
18074 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18076 export function SpendableOutputDescriptor_write(obj: number): number {
18077 if(!isWasmInitialized) {
18078 throw new Error("initializeWasm() must be awaited first!");
18080 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18081 return nativeResponseValue;
18083 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18085 export function SpendableOutputDescriptor_read(ser: number): number {
18086 if(!isWasmInitialized) {
18087 throw new Error("initializeWasm() must be awaited first!");
18089 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18090 return nativeResponseValue;
18092 // void BaseSign_free(struct LDKBaseSign this_ptr);
18094 export function BaseSign_free(this_ptr: number): void {
18095 if(!isWasmInitialized) {
18096 throw new Error("initializeWasm() must be awaited first!");
18098 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18099 // debug statements here
18101 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18103 export function Sign_clone_ptr(arg: number): number {
18104 if(!isWasmInitialized) {
18105 throw new Error("initializeWasm() must be awaited first!");
18107 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18108 return nativeResponseValue;
18110 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18112 export function Sign_clone(orig: number): number {
18113 if(!isWasmInitialized) {
18114 throw new Error("initializeWasm() must be awaited first!");
18116 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18117 return nativeResponseValue;
18119 // void Sign_free(struct LDKSign this_ptr);
18121 export function Sign_free(this_ptr: number): void {
18122 if(!isWasmInitialized) {
18123 throw new Error("initializeWasm() must be awaited first!");
18125 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18126 // debug statements here
18128 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18130 export function Recipient_clone(orig: number): Recipient {
18131 if(!isWasmInitialized) {
18132 throw new Error("initializeWasm() must be awaited first!");
18134 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18135 return nativeResponseValue;
18137 // enum LDKRecipient Recipient_node(void);
18139 export function Recipient_node(): Recipient {
18140 if(!isWasmInitialized) {
18141 throw new Error("initializeWasm() must be awaited first!");
18143 const nativeResponseValue = wasm.TS_Recipient_node();
18144 return nativeResponseValue;
18146 // enum LDKRecipient Recipient_phantom_node(void);
18148 export function Recipient_phantom_node(): Recipient {
18149 if(!isWasmInitialized) {
18150 throw new Error("initializeWasm() must be awaited first!");
18152 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18153 return nativeResponseValue;
18155 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18157 export function KeysInterface_free(this_ptr: number): void {
18158 if(!isWasmInitialized) {
18159 throw new Error("initializeWasm() must be awaited first!");
18161 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18162 // debug statements here
18164 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18166 export function InMemorySigner_free(this_obj: number): void {
18167 if(!isWasmInitialized) {
18168 throw new Error("initializeWasm() must be awaited first!");
18170 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18171 // debug statements here
18173 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18175 export function InMemorySigner_get_funding_key(this_ptr: number): number {
18176 if(!isWasmInitialized) {
18177 throw new Error("initializeWasm() must be awaited first!");
18179 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18180 return nativeResponseValue;
18182 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18184 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
18185 if(!isWasmInitialized) {
18186 throw new Error("initializeWasm() must be awaited first!");
18188 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18189 // debug statements here
18191 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18193 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
18194 if(!isWasmInitialized) {
18195 throw new Error("initializeWasm() must be awaited first!");
18197 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18198 return nativeResponseValue;
18200 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18202 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
18203 if(!isWasmInitialized) {
18204 throw new Error("initializeWasm() must be awaited first!");
18206 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18207 // debug statements here
18209 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18211 export function InMemorySigner_get_payment_key(this_ptr: number): number {
18212 if(!isWasmInitialized) {
18213 throw new Error("initializeWasm() must be awaited first!");
18215 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18216 return nativeResponseValue;
18218 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18220 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
18221 if(!isWasmInitialized) {
18222 throw new Error("initializeWasm() must be awaited first!");
18224 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18225 // debug statements here
18227 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18229 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
18230 if(!isWasmInitialized) {
18231 throw new Error("initializeWasm() must be awaited first!");
18233 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18234 return nativeResponseValue;
18236 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18238 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
18239 if(!isWasmInitialized) {
18240 throw new Error("initializeWasm() must be awaited first!");
18242 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18243 // debug statements here
18245 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18247 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
18248 if(!isWasmInitialized) {
18249 throw new Error("initializeWasm() must be awaited first!");
18251 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18252 return nativeResponseValue;
18254 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18256 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
18257 if(!isWasmInitialized) {
18258 throw new Error("initializeWasm() must be awaited first!");
18260 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18261 // debug statements here
18263 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18265 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
18266 if(!isWasmInitialized) {
18267 throw new Error("initializeWasm() must be awaited first!");
18269 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
18270 return nativeResponseValue;
18272 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18274 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
18275 if(!isWasmInitialized) {
18276 throw new Error("initializeWasm() must be awaited first!");
18278 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
18279 // debug statements here
18281 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
18283 export function InMemorySigner_clone_ptr(arg: number): number {
18284 if(!isWasmInitialized) {
18285 throw new Error("initializeWasm() must be awaited first!");
18287 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
18288 return nativeResponseValue;
18290 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
18292 export function InMemorySigner_clone(orig: number): number {
18293 if(!isWasmInitialized) {
18294 throw new Error("initializeWasm() must be awaited first!");
18296 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
18297 return nativeResponseValue;
18299 // MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey node_secret, 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);
18301 export function InMemorySigner_new(node_secret: number, 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 {
18302 if(!isWasmInitialized) {
18303 throw new Error("initializeWasm() must be awaited first!");
18305 const nativeResponseValue = wasm.TS_InMemorySigner_new(node_secret, funding_key, revocation_base_key, payment_key, delayed_payment_base_key, htlc_base_key, commitment_seed, channel_value_satoshis, channel_keys_id);
18306 return nativeResponseValue;
18308 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18310 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
18311 if(!isWasmInitialized) {
18312 throw new Error("initializeWasm() must be awaited first!");
18314 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
18315 return nativeResponseValue;
18317 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18319 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
18320 if(!isWasmInitialized) {
18321 throw new Error("initializeWasm() must be awaited first!");
18323 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
18324 return nativeResponseValue;
18326 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18328 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
18329 if(!isWasmInitialized) {
18330 throw new Error("initializeWasm() must be awaited first!");
18332 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
18333 return nativeResponseValue;
18335 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18337 export function InMemorySigner_is_outbound(this_arg: number): boolean {
18338 if(!isWasmInitialized) {
18339 throw new Error("initializeWasm() must be awaited first!");
18341 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
18342 return nativeResponseValue;
18344 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18346 export function InMemorySigner_funding_outpoint(this_arg: number): number {
18347 if(!isWasmInitialized) {
18348 throw new Error("initializeWasm() must be awaited first!");
18350 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
18351 return nativeResponseValue;
18353 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18355 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
18356 if(!isWasmInitialized) {
18357 throw new Error("initializeWasm() must be awaited first!");
18359 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
18360 return nativeResponseValue;
18362 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18364 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
18365 if(!isWasmInitialized) {
18366 throw new Error("initializeWasm() must be awaited first!");
18368 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
18369 return nativeResponseValue;
18371 // 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);
18373 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18374 if(!isWasmInitialized) {
18375 throw new Error("initializeWasm() must be awaited first!");
18377 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
18378 return nativeResponseValue;
18380 // 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);
18382 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18383 if(!isWasmInitialized) {
18384 throw new Error("initializeWasm() must be awaited first!");
18386 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
18387 return nativeResponseValue;
18389 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18391 export function InMemorySigner_as_BaseSign(this_arg: number): number {
18392 if(!isWasmInitialized) {
18393 throw new Error("initializeWasm() must be awaited first!");
18395 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
18396 return nativeResponseValue;
18398 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18400 export function InMemorySigner_as_Sign(this_arg: number): number {
18401 if(!isWasmInitialized) {
18402 throw new Error("initializeWasm() must be awaited first!");
18404 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
18405 return nativeResponseValue;
18407 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
18409 export function InMemorySigner_write(obj: number): number {
18410 if(!isWasmInitialized) {
18411 throw new Error("initializeWasm() must be awaited first!");
18413 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
18414 return nativeResponseValue;
18416 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
18418 export function InMemorySigner_read(ser: number, arg: number): number {
18419 if(!isWasmInitialized) {
18420 throw new Error("initializeWasm() must be awaited first!");
18422 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
18423 return nativeResponseValue;
18425 // void KeysManager_free(struct LDKKeysManager this_obj);
18427 export function KeysManager_free(this_obj: number): void {
18428 if(!isWasmInitialized) {
18429 throw new Error("initializeWasm() must be awaited first!");
18431 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
18432 // debug statements here
18434 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
18436 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
18437 if(!isWasmInitialized) {
18438 throw new Error("initializeWasm() must be awaited first!");
18440 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
18441 return nativeResponseValue;
18443 // 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]);
18445 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18446 if(!isWasmInitialized) {
18447 throw new Error("initializeWasm() must be awaited first!");
18449 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18450 return nativeResponseValue;
18452 // 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);
18454 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18455 if(!isWasmInitialized) {
18456 throw new Error("initializeWasm() must be awaited first!");
18458 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18459 return nativeResponseValue;
18461 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
18463 export function KeysManager_as_KeysInterface(this_arg: number): number {
18464 if(!isWasmInitialized) {
18465 throw new Error("initializeWasm() must be awaited first!");
18467 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
18468 return nativeResponseValue;
18470 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
18472 export function PhantomKeysManager_free(this_obj: number): void {
18473 if(!isWasmInitialized) {
18474 throw new Error("initializeWasm() must be awaited first!");
18476 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
18477 // debug statements here
18479 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
18481 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
18482 if(!isWasmInitialized) {
18483 throw new Error("initializeWasm() must be awaited first!");
18485 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
18486 return nativeResponseValue;
18488 // MUST_USE_RES struct LDKPhantomKeysManager PhantomKeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos, const uint8_t (*cross_node_seed)[32]);
18490 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
18491 if(!isWasmInitialized) {
18492 throw new Error("initializeWasm() must be awaited first!");
18494 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
18495 return nativeResponseValue;
18497 // MUST_USE_RES struct LDKCResult_TransactionNoneZ PhantomKeysManager_spend_spendable_outputs(const struct LDKPhantomKeysManager *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);
18499 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18500 if(!isWasmInitialized) {
18501 throw new Error("initializeWasm() must be awaited first!");
18503 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18504 return nativeResponseValue;
18506 // MUST_USE_RES struct LDKInMemorySigner PhantomKeysManager_derive_channel_keys(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, const uint8_t (*params)[32]);
18508 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18509 if(!isWasmInitialized) {
18510 throw new Error("initializeWasm() must be awaited first!");
18512 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18513 return nativeResponseValue;
18515 // void ChannelManager_free(struct LDKChannelManager this_obj);
18517 export function ChannelManager_free(this_obj: number): void {
18518 if(!isWasmInitialized) {
18519 throw new Error("initializeWasm() must be awaited first!");
18521 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
18522 // debug statements here
18524 // void ChainParameters_free(struct LDKChainParameters this_obj);
18526 export function ChainParameters_free(this_obj: number): void {
18527 if(!isWasmInitialized) {
18528 throw new Error("initializeWasm() must be awaited first!");
18530 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
18531 // debug statements here
18533 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18535 export function ChainParameters_get_network(this_ptr: number): Network {
18536 if(!isWasmInitialized) {
18537 throw new Error("initializeWasm() must be awaited first!");
18539 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
18540 return nativeResponseValue;
18542 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
18544 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
18545 if(!isWasmInitialized) {
18546 throw new Error("initializeWasm() must be awaited first!");
18548 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
18549 // debug statements here
18551 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18553 export function ChainParameters_get_best_block(this_ptr: number): number {
18554 if(!isWasmInitialized) {
18555 throw new Error("initializeWasm() must be awaited first!");
18557 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
18558 return nativeResponseValue;
18560 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
18562 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
18563 if(!isWasmInitialized) {
18564 throw new Error("initializeWasm() must be awaited first!");
18566 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
18567 // debug statements here
18569 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
18571 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
18572 if(!isWasmInitialized) {
18573 throw new Error("initializeWasm() must be awaited first!");
18575 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
18576 return nativeResponseValue;
18578 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
18580 export function ChainParameters_clone_ptr(arg: number): number {
18581 if(!isWasmInitialized) {
18582 throw new Error("initializeWasm() must be awaited first!");
18584 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
18585 return nativeResponseValue;
18587 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
18589 export function ChainParameters_clone(orig: number): number {
18590 if(!isWasmInitialized) {
18591 throw new Error("initializeWasm() must be awaited first!");
18593 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
18594 return nativeResponseValue;
18596 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
18598 export function CounterpartyForwardingInfo_free(this_obj: number): void {
18599 if(!isWasmInitialized) {
18600 throw new Error("initializeWasm() must be awaited first!");
18602 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
18603 // debug statements here
18605 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18607 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
18608 if(!isWasmInitialized) {
18609 throw new Error("initializeWasm() must be awaited first!");
18611 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
18612 return nativeResponseValue;
18614 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18616 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
18617 if(!isWasmInitialized) {
18618 throw new Error("initializeWasm() must be awaited first!");
18620 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
18621 // debug statements here
18623 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18625 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
18626 if(!isWasmInitialized) {
18627 throw new Error("initializeWasm() must be awaited first!");
18629 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
18630 return nativeResponseValue;
18632 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18634 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
18635 if(!isWasmInitialized) {
18636 throw new Error("initializeWasm() must be awaited first!");
18638 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
18639 // debug statements here
18641 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18643 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
18644 if(!isWasmInitialized) {
18645 throw new Error("initializeWasm() must be awaited first!");
18647 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
18648 return nativeResponseValue;
18650 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
18652 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
18653 if(!isWasmInitialized) {
18654 throw new Error("initializeWasm() must be awaited first!");
18656 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
18657 // debug statements here
18659 // 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);
18661 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
18662 if(!isWasmInitialized) {
18663 throw new Error("initializeWasm() must be awaited first!");
18665 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
18666 return nativeResponseValue;
18668 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
18670 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
18671 if(!isWasmInitialized) {
18672 throw new Error("initializeWasm() must be awaited first!");
18674 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
18675 return nativeResponseValue;
18677 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
18679 export function CounterpartyForwardingInfo_clone(orig: number): number {
18680 if(!isWasmInitialized) {
18681 throw new Error("initializeWasm() must be awaited first!");
18683 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
18684 return nativeResponseValue;
18686 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
18688 export function ChannelCounterparty_free(this_obj: number): void {
18689 if(!isWasmInitialized) {
18690 throw new Error("initializeWasm() must be awaited first!");
18692 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
18693 // debug statements here
18695 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18697 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18698 if(!isWasmInitialized) {
18699 throw new Error("initializeWasm() must be awaited first!");
18701 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18702 return nativeResponseValue;
18704 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18706 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18707 if(!isWasmInitialized) {
18708 throw new Error("initializeWasm() must be awaited first!");
18710 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18711 // debug statements here
18713 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18715 export function ChannelCounterparty_get_features(this_ptr: number): number {
18716 if(!isWasmInitialized) {
18717 throw new Error("initializeWasm() must be awaited first!");
18719 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18720 return nativeResponseValue;
18722 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18724 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18725 if(!isWasmInitialized) {
18726 throw new Error("initializeWasm() must be awaited first!");
18728 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18729 // debug statements here
18731 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18733 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18734 if(!isWasmInitialized) {
18735 throw new Error("initializeWasm() must be awaited first!");
18737 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18738 return nativeResponseValue;
18740 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18742 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18743 if(!isWasmInitialized) {
18744 throw new Error("initializeWasm() must be awaited first!");
18746 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18747 // debug statements here
18749 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18751 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18752 if(!isWasmInitialized) {
18753 throw new Error("initializeWasm() must be awaited first!");
18755 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
18756 return nativeResponseValue;
18758 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
18760 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
18761 if(!isWasmInitialized) {
18762 throw new Error("initializeWasm() must be awaited first!");
18764 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
18765 // debug statements here
18767 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18769 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: number): number {
18770 if(!isWasmInitialized) {
18771 throw new Error("initializeWasm() must be awaited first!");
18773 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
18774 return nativeResponseValue;
18776 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18778 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: number, val: number): void {
18779 if(!isWasmInitialized) {
18780 throw new Error("initializeWasm() must be awaited first!");
18782 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
18783 // debug statements here
18785 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18787 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: number): number {
18788 if(!isWasmInitialized) {
18789 throw new Error("initializeWasm() must be awaited first!");
18791 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
18792 return nativeResponseValue;
18794 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18796 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: number, val: number): void {
18797 if(!isWasmInitialized) {
18798 throw new Error("initializeWasm() must be awaited first!");
18800 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
18801 // debug statements here
18803 // 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, struct LDKCOption_u64Z outbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z outbound_htlc_maximum_msat_arg);
18805 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number, outbound_htlc_minimum_msat_arg: number, outbound_htlc_maximum_msat_arg: number): number {
18806 if(!isWasmInitialized) {
18807 throw new Error("initializeWasm() must be awaited first!");
18809 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg, outbound_htlc_minimum_msat_arg, outbound_htlc_maximum_msat_arg);
18810 return nativeResponseValue;
18812 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
18814 export function ChannelCounterparty_clone_ptr(arg: number): number {
18815 if(!isWasmInitialized) {
18816 throw new Error("initializeWasm() must be awaited first!");
18818 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
18819 return nativeResponseValue;
18821 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
18823 export function ChannelCounterparty_clone(orig: number): number {
18824 if(!isWasmInitialized) {
18825 throw new Error("initializeWasm() must be awaited first!");
18827 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
18828 return nativeResponseValue;
18830 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
18832 export function ChannelDetails_free(this_obj: number): void {
18833 if(!isWasmInitialized) {
18834 throw new Error("initializeWasm() must be awaited first!");
18836 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
18837 // debug statements here
18839 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
18841 export function ChannelDetails_get_channel_id(this_ptr: number): number {
18842 if(!isWasmInitialized) {
18843 throw new Error("initializeWasm() must be awaited first!");
18845 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
18846 return nativeResponseValue;
18848 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18850 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
18851 if(!isWasmInitialized) {
18852 throw new Error("initializeWasm() must be awaited first!");
18854 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
18855 // debug statements here
18857 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18859 export function ChannelDetails_get_counterparty(this_ptr: number): number {
18860 if(!isWasmInitialized) {
18861 throw new Error("initializeWasm() must be awaited first!");
18863 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
18864 return nativeResponseValue;
18866 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
18868 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
18869 if(!isWasmInitialized) {
18870 throw new Error("initializeWasm() must be awaited first!");
18872 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
18873 // debug statements here
18875 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18877 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
18878 if(!isWasmInitialized) {
18879 throw new Error("initializeWasm() must be awaited first!");
18881 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
18882 return nativeResponseValue;
18884 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18886 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
18887 if(!isWasmInitialized) {
18888 throw new Error("initializeWasm() must be awaited first!");
18890 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
18891 // debug statements here
18893 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18895 export function ChannelDetails_get_channel_type(this_ptr: number): number {
18896 if(!isWasmInitialized) {
18897 throw new Error("initializeWasm() must be awaited first!");
18899 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
18900 return nativeResponseValue;
18902 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
18904 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
18905 if(!isWasmInitialized) {
18906 throw new Error("initializeWasm() must be awaited first!");
18908 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
18909 // debug statements here
18911 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18913 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
18914 if(!isWasmInitialized) {
18915 throw new Error("initializeWasm() must be awaited first!");
18917 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
18918 return nativeResponseValue;
18920 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18922 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
18923 if(!isWasmInitialized) {
18924 throw new Error("initializeWasm() must be awaited first!");
18926 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
18927 // debug statements here
18929 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18931 export function ChannelDetails_get_outbound_scid_alias(this_ptr: number): number {
18932 if(!isWasmInitialized) {
18933 throw new Error("initializeWasm() must be awaited first!");
18935 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
18936 return nativeResponseValue;
18938 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18940 export function ChannelDetails_set_outbound_scid_alias(this_ptr: number, val: number): void {
18941 if(!isWasmInitialized) {
18942 throw new Error("initializeWasm() must be awaited first!");
18944 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
18945 // debug statements here
18947 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18949 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
18950 if(!isWasmInitialized) {
18951 throw new Error("initializeWasm() must be awaited first!");
18953 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
18954 return nativeResponseValue;
18956 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18958 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
18959 if(!isWasmInitialized) {
18960 throw new Error("initializeWasm() must be awaited first!");
18962 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
18963 // debug statements here
18965 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18967 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
18968 if(!isWasmInitialized) {
18969 throw new Error("initializeWasm() must be awaited first!");
18971 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
18972 return nativeResponseValue;
18974 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18976 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18977 if(!isWasmInitialized) {
18978 throw new Error("initializeWasm() must be awaited first!");
18980 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
18981 // debug statements here
18983 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18985 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
18986 if(!isWasmInitialized) {
18987 throw new Error("initializeWasm() must be awaited first!");
18989 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
18990 return nativeResponseValue;
18992 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18994 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
18995 if(!isWasmInitialized) {
18996 throw new Error("initializeWasm() must be awaited first!");
18998 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
18999 // debug statements here
19001 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19003 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
19004 if(!isWasmInitialized) {
19005 throw new Error("initializeWasm() must be awaited first!");
19007 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19008 return nativeResponseValue;
19010 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19012 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
19013 if(!isWasmInitialized) {
19014 throw new Error("initializeWasm() must be awaited first!");
19016 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19017 // debug statements here
19019 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19021 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
19022 if(!isWasmInitialized) {
19023 throw new Error("initializeWasm() must be awaited first!");
19025 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19026 return nativeResponseValue;
19028 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19030 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
19031 if(!isWasmInitialized) {
19032 throw new Error("initializeWasm() must be awaited first!");
19034 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19035 // debug statements here
19037 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19039 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
19040 if(!isWasmInitialized) {
19041 throw new Error("initializeWasm() must be awaited first!");
19043 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19044 return nativeResponseValue;
19046 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19048 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
19049 if(!isWasmInitialized) {
19050 throw new Error("initializeWasm() must be awaited first!");
19052 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19053 // debug statements here
19055 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19057 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: number): bigint {
19058 if(!isWasmInitialized) {
19059 throw new Error("initializeWasm() must be awaited first!");
19061 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19062 return nativeResponseValue;
19064 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19066 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: number, val: bigint): void {
19067 if(!isWasmInitialized) {
19068 throw new Error("initializeWasm() must be awaited first!");
19070 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19071 // debug statements here
19073 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19075 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
19076 if(!isWasmInitialized) {
19077 throw new Error("initializeWasm() must be awaited first!");
19079 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19080 return nativeResponseValue;
19082 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19084 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
19085 if(!isWasmInitialized) {
19086 throw new Error("initializeWasm() must be awaited first!");
19088 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19089 // debug statements here
19091 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19093 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
19094 if(!isWasmInitialized) {
19095 throw new Error("initializeWasm() must be awaited first!");
19097 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19098 return nativeResponseValue;
19100 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19102 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
19103 if(!isWasmInitialized) {
19104 throw new Error("initializeWasm() must be awaited first!");
19106 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19107 // debug statements here
19109 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19111 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
19112 if(!isWasmInitialized) {
19113 throw new Error("initializeWasm() must be awaited first!");
19115 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19116 return nativeResponseValue;
19118 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19120 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
19121 if(!isWasmInitialized) {
19122 throw new Error("initializeWasm() must be awaited first!");
19124 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19125 // debug statements here
19127 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19129 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
19130 if(!isWasmInitialized) {
19131 throw new Error("initializeWasm() must be awaited first!");
19133 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19134 return nativeResponseValue;
19136 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19138 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
19139 if(!isWasmInitialized) {
19140 throw new Error("initializeWasm() must be awaited first!");
19142 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19143 // debug statements here
19145 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19147 export function ChannelDetails_get_is_channel_ready(this_ptr: number): boolean {
19148 if(!isWasmInitialized) {
19149 throw new Error("initializeWasm() must be awaited first!");
19151 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19152 return nativeResponseValue;
19154 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19156 export function ChannelDetails_set_is_channel_ready(this_ptr: number, val: boolean): void {
19157 if(!isWasmInitialized) {
19158 throw new Error("initializeWasm() must be awaited first!");
19160 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19161 // debug statements here
19163 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19165 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
19166 if(!isWasmInitialized) {
19167 throw new Error("initializeWasm() must be awaited first!");
19169 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19170 return nativeResponseValue;
19172 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19174 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
19175 if(!isWasmInitialized) {
19176 throw new Error("initializeWasm() must be awaited first!");
19178 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19179 // debug statements here
19181 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19183 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
19184 if(!isWasmInitialized) {
19185 throw new Error("initializeWasm() must be awaited first!");
19187 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19188 return nativeResponseValue;
19190 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19192 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
19193 if(!isWasmInitialized) {
19194 throw new Error("initializeWasm() must be awaited first!");
19196 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19197 // debug statements here
19199 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19201 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: number): number {
19202 if(!isWasmInitialized) {
19203 throw new Error("initializeWasm() must be awaited first!");
19205 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19206 return nativeResponseValue;
19208 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19210 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19211 if(!isWasmInitialized) {
19212 throw new Error("initializeWasm() must be awaited first!");
19214 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19215 // debug statements here
19217 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19219 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: number): number {
19220 if(!isWasmInitialized) {
19221 throw new Error("initializeWasm() must be awaited first!");
19223 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19224 return nativeResponseValue;
19226 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19228 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19229 if(!isWasmInitialized) {
19230 throw new Error("initializeWasm() must be awaited first!");
19232 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19233 // debug statements here
19235 // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_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 next_outbound_htlc_limit_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_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg);
19237 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: number, funding_txo_arg: number, channel_type_arg: number, short_channel_id_arg: number, outbound_scid_alias_arg: number, inbound_scid_alias_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, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: number, inbound_htlc_maximum_msat_arg: number): number {
19238 if(!isWasmInitialized) {
19239 throw new Error("initializeWasm() must be awaited first!");
19241 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg);
19242 return nativeResponseValue;
19244 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19246 export function ChannelDetails_clone_ptr(arg: number): number {
19247 if(!isWasmInitialized) {
19248 throw new Error("initializeWasm() must be awaited first!");
19250 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
19251 return nativeResponseValue;
19253 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
19255 export function ChannelDetails_clone(orig: number): number {
19256 if(!isWasmInitialized) {
19257 throw new Error("initializeWasm() must be awaited first!");
19259 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
19260 return nativeResponseValue;
19262 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19264 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
19265 if(!isWasmInitialized) {
19266 throw new Error("initializeWasm() must be awaited first!");
19268 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
19269 return nativeResponseValue;
19271 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19273 export function ChannelDetails_get_outbound_payment_scid(this_arg: number): number {
19274 if(!isWasmInitialized) {
19275 throw new Error("initializeWasm() must be awaited first!");
19277 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
19278 return nativeResponseValue;
19280 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
19282 export function PaymentSendFailure_free(this_ptr: number): void {
19283 if(!isWasmInitialized) {
19284 throw new Error("initializeWasm() must be awaited first!");
19286 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
19287 // debug statements here
19289 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
19291 export function PaymentSendFailure_clone_ptr(arg: number): number {
19292 if(!isWasmInitialized) {
19293 throw new Error("initializeWasm() must be awaited first!");
19295 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
19296 return nativeResponseValue;
19298 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
19300 export function PaymentSendFailure_clone(orig: number): number {
19301 if(!isWasmInitialized) {
19302 throw new Error("initializeWasm() must be awaited first!");
19304 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
19305 return nativeResponseValue;
19307 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
19309 export function PaymentSendFailure_parameter_error(a: number): number {
19310 if(!isWasmInitialized) {
19311 throw new Error("initializeWasm() must be awaited first!");
19313 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
19314 return nativeResponseValue;
19316 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
19318 export function PaymentSendFailure_path_parameter_error(a: number): number {
19319 if(!isWasmInitialized) {
19320 throw new Error("initializeWasm() must be awaited first!");
19322 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
19323 return nativeResponseValue;
19325 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
19327 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
19328 if(!isWasmInitialized) {
19329 throw new Error("initializeWasm() must be awaited first!");
19331 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
19332 return nativeResponseValue;
19334 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
19336 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
19337 if(!isWasmInitialized) {
19338 throw new Error("initializeWasm() must be awaited first!");
19340 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
19341 return nativeResponseValue;
19343 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
19345 export function PhantomRouteHints_free(this_obj: number): void {
19346 if(!isWasmInitialized) {
19347 throw new Error("initializeWasm() must be awaited first!");
19349 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
19350 // debug statements here
19352 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19354 export function PhantomRouteHints_get_channels(this_ptr: number): number {
19355 if(!isWasmInitialized) {
19356 throw new Error("initializeWasm() must be awaited first!");
19358 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
19359 return nativeResponseValue;
19361 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
19363 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
19364 if(!isWasmInitialized) {
19365 throw new Error("initializeWasm() must be awaited first!");
19367 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
19368 // debug statements here
19370 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19372 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
19373 if(!isWasmInitialized) {
19374 throw new Error("initializeWasm() must be awaited first!");
19376 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
19377 return nativeResponseValue;
19379 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
19381 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
19382 if(!isWasmInitialized) {
19383 throw new Error("initializeWasm() must be awaited first!");
19385 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
19386 // debug statements here
19388 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19390 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
19391 if(!isWasmInitialized) {
19392 throw new Error("initializeWasm() must be awaited first!");
19394 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
19395 return nativeResponseValue;
19397 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19399 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
19400 if(!isWasmInitialized) {
19401 throw new Error("initializeWasm() must be awaited first!");
19403 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
19404 // debug statements here
19406 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
19408 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
19409 if(!isWasmInitialized) {
19410 throw new Error("initializeWasm() must be awaited first!");
19412 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
19413 return nativeResponseValue;
19415 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
19417 export function PhantomRouteHints_clone_ptr(arg: number): number {
19418 if(!isWasmInitialized) {
19419 throw new Error("initializeWasm() must be awaited first!");
19421 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
19422 return nativeResponseValue;
19424 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
19426 export function PhantomRouteHints_clone(orig: number): number {
19427 if(!isWasmInitialized) {
19428 throw new Error("initializeWasm() must be awaited first!");
19430 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
19431 return nativeResponseValue;
19433 // 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);
19435 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
19436 if(!isWasmInitialized) {
19437 throw new Error("initializeWasm() must be awaited first!");
19439 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
19440 return nativeResponseValue;
19442 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
19444 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
19445 if(!isWasmInitialized) {
19446 throw new Error("initializeWasm() must be awaited first!");
19448 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
19449 return nativeResponseValue;
19451 // 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);
19453 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 {
19454 if(!isWasmInitialized) {
19455 throw new Error("initializeWasm() must be awaited first!");
19457 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
19458 return nativeResponseValue;
19460 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19462 export function ChannelManager_list_channels(this_arg: number): number {
19463 if(!isWasmInitialized) {
19464 throw new Error("initializeWasm() must be awaited first!");
19466 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
19467 return nativeResponseValue;
19469 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19471 export function ChannelManager_list_usable_channels(this_arg: number): number {
19472 if(!isWasmInitialized) {
19473 throw new Error("initializeWasm() must be awaited first!");
19475 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
19476 return nativeResponseValue;
19478 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
19480 export function ChannelManager_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19481 if(!isWasmInitialized) {
19482 throw new Error("initializeWasm() must be awaited first!");
19484 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
19485 return nativeResponseValue;
19487 // 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], struct LDKPublicKey counterparty_node_id, uint32_t target_feerate_sats_per_1000_weight);
19489 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, counterparty_node_id: number, target_feerate_sats_per_1000_weight: number): number {
19490 if(!isWasmInitialized) {
19491 throw new Error("initializeWasm() must be awaited first!");
19493 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
19494 return nativeResponseValue;
19496 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
19498 export function ChannelManager_force_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19499 if(!isWasmInitialized) {
19500 throw new Error("initializeWasm() must be awaited first!");
19502 const nativeResponseValue = wasm.TS_ChannelManager_force_close_channel(this_arg, channel_id, counterparty_node_id);
19503 return nativeResponseValue;
19505 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19507 export function ChannelManager_force_close_all_channels(this_arg: number): void {
19508 if(!isWasmInitialized) {
19509 throw new Error("initializeWasm() must be awaited first!");
19511 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
19512 // debug statements here
19514 // 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);
19516 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
19517 if(!isWasmInitialized) {
19518 throw new Error("initializeWasm() must be awaited first!");
19520 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
19521 return nativeResponseValue;
19523 // 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);
19525 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
19526 if(!isWasmInitialized) {
19527 throw new Error("initializeWasm() must be awaited first!");
19529 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
19530 return nativeResponseValue;
19532 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
19534 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
19535 if(!isWasmInitialized) {
19536 throw new Error("initializeWasm() must be awaited first!");
19538 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
19539 // debug statements here
19541 // 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);
19543 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
19544 if(!isWasmInitialized) {
19545 throw new Error("initializeWasm() must be awaited first!");
19547 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
19548 return nativeResponseValue;
19550 // 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 LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
19552 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): number {
19553 if(!isWasmInitialized) {
19554 throw new Error("initializeWasm() must be awaited first!");
19556 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
19557 return nativeResponseValue;
19559 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
19561 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
19562 if(!isWasmInitialized) {
19563 throw new Error("initializeWasm() must be awaited first!");
19565 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
19566 // debug statements here
19568 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
19570 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
19571 if(!isWasmInitialized) {
19572 throw new Error("initializeWasm() must be awaited first!");
19574 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
19575 // debug statements here
19577 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
19579 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
19580 if(!isWasmInitialized) {
19581 throw new Error("initializeWasm() must be awaited first!");
19583 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
19584 // debug statements here
19586 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
19588 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): void {
19589 if(!isWasmInitialized) {
19590 throw new Error("initializeWasm() must be awaited first!");
19592 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
19593 // debug statements here
19595 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
19597 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): void {
19598 if(!isWasmInitialized) {
19599 throw new Error("initializeWasm() must be awaited first!");
19601 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
19602 // debug statements here
19604 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
19606 export function ChannelManager_get_our_node_id(this_arg: number): number {
19607 if(!isWasmInitialized) {
19608 throw new Error("initializeWasm() must be awaited first!");
19610 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
19611 return nativeResponseValue;
19613 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, uint64_t user_channel_id);
19615 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
19616 if(!isWasmInitialized) {
19617 throw new Error("initializeWasm() must be awaited first!");
19619 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19620 return nativeResponseValue;
19622 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKPublicKey counterparty_node_id, uint64_t user_channel_id);
19624 export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
19625 if(!isWasmInitialized) {
19626 throw new Error("initializeWasm() must be awaited first!");
19628 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19629 return nativeResponseValue;
19631 // 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);
19633 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19634 if(!isWasmInitialized) {
19635 throw new Error("initializeWasm() must be awaited first!");
19637 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
19638 return nativeResponseValue;
19640 // 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);
19642 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19643 if(!isWasmInitialized) {
19644 throw new Error("initializeWasm() must be awaited first!");
19646 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
19647 return nativeResponseValue;
19649 // 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);
19651 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19652 if(!isWasmInitialized) {
19653 throw new Error("initializeWasm() must be awaited first!");
19655 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19656 return nativeResponseValue;
19658 // 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);
19660 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 {
19661 if(!isWasmInitialized) {
19662 throw new Error("initializeWasm() must be awaited first!");
19664 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19665 return nativeResponseValue;
19667 // 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);
19669 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
19670 if(!isWasmInitialized) {
19671 throw new Error("initializeWasm() must be awaited first!");
19673 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
19674 return nativeResponseValue;
19676 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
19678 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
19679 if(!isWasmInitialized) {
19680 throw new Error("initializeWasm() must be awaited first!");
19682 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
19683 return nativeResponseValue;
19685 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
19687 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
19688 if(!isWasmInitialized) {
19689 throw new Error("initializeWasm() must be awaited first!");
19691 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
19692 return nativeResponseValue;
19694 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19696 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
19697 if(!isWasmInitialized) {
19698 throw new Error("initializeWasm() must be awaited first!");
19700 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
19701 return nativeResponseValue;
19703 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19705 export function ChannelManager_as_EventsProvider(this_arg: number): number {
19706 if(!isWasmInitialized) {
19707 throw new Error("initializeWasm() must be awaited first!");
19709 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
19710 return nativeResponseValue;
19712 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
19714 export function ChannelManager_as_Listen(this_arg: number): number {
19715 if(!isWasmInitialized) {
19716 throw new Error("initializeWasm() must be awaited first!");
19718 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
19719 return nativeResponseValue;
19721 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
19723 export function ChannelManager_as_Confirm(this_arg: number): number {
19724 if(!isWasmInitialized) {
19725 throw new Error("initializeWasm() must be awaited first!");
19727 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
19728 return nativeResponseValue;
19730 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
19732 export function ChannelManager_await_persistable_update(this_arg: number): void {
19733 if(!isWasmInitialized) {
19734 throw new Error("initializeWasm() must be awaited first!");
19736 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
19737 // debug statements here
19739 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
19741 export function ChannelManager_current_best_block(this_arg: number): number {
19742 if(!isWasmInitialized) {
19743 throw new Error("initializeWasm() must be awaited first!");
19745 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
19746 return nativeResponseValue;
19748 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
19750 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
19751 if(!isWasmInitialized) {
19752 throw new Error("initializeWasm() must be awaited first!");
19754 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
19755 return nativeResponseValue;
19757 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
19759 export function CounterpartyForwardingInfo_write(obj: number): number {
19760 if(!isWasmInitialized) {
19761 throw new Error("initializeWasm() must be awaited first!");
19763 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
19764 return nativeResponseValue;
19766 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
19768 export function CounterpartyForwardingInfo_read(ser: number): number {
19769 if(!isWasmInitialized) {
19770 throw new Error("initializeWasm() must be awaited first!");
19772 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
19773 return nativeResponseValue;
19775 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
19777 export function ChannelCounterparty_write(obj: number): number {
19778 if(!isWasmInitialized) {
19779 throw new Error("initializeWasm() must be awaited first!");
19781 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
19782 return nativeResponseValue;
19784 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
19786 export function ChannelCounterparty_read(ser: number): number {
19787 if(!isWasmInitialized) {
19788 throw new Error("initializeWasm() must be awaited first!");
19790 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
19791 return nativeResponseValue;
19793 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
19795 export function ChannelDetails_write(obj: number): number {
19796 if(!isWasmInitialized) {
19797 throw new Error("initializeWasm() must be awaited first!");
19799 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
19800 return nativeResponseValue;
19802 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
19804 export function ChannelDetails_read(ser: number): number {
19805 if(!isWasmInitialized) {
19806 throw new Error("initializeWasm() must be awaited first!");
19808 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
19809 return nativeResponseValue;
19811 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
19813 export function PhantomRouteHints_write(obj: number): number {
19814 if(!isWasmInitialized) {
19815 throw new Error("initializeWasm() must be awaited first!");
19817 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
19818 return nativeResponseValue;
19820 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
19822 export function PhantomRouteHints_read(ser: number): number {
19823 if(!isWasmInitialized) {
19824 throw new Error("initializeWasm() must be awaited first!");
19826 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
19827 return nativeResponseValue;
19829 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
19831 export function ChannelManager_write(obj: number): number {
19832 if(!isWasmInitialized) {
19833 throw new Error("initializeWasm() must be awaited first!");
19835 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
19836 return nativeResponseValue;
19838 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
19840 export function ChannelManagerReadArgs_free(this_obj: number): void {
19841 if(!isWasmInitialized) {
19842 throw new Error("initializeWasm() must be awaited first!");
19844 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
19845 // debug statements here
19847 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19849 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
19850 if(!isWasmInitialized) {
19851 throw new Error("initializeWasm() must be awaited first!");
19853 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
19854 return nativeResponseValue;
19856 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
19858 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
19859 if(!isWasmInitialized) {
19860 throw new Error("initializeWasm() must be awaited first!");
19862 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
19863 // debug statements here
19865 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19867 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
19868 if(!isWasmInitialized) {
19869 throw new Error("initializeWasm() must be awaited first!");
19871 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
19872 return nativeResponseValue;
19874 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
19876 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
19877 if(!isWasmInitialized) {
19878 throw new Error("initializeWasm() must be awaited first!");
19880 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
19881 // debug statements here
19883 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19885 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
19886 if(!isWasmInitialized) {
19887 throw new Error("initializeWasm() must be awaited first!");
19889 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
19890 return nativeResponseValue;
19892 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
19894 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
19895 if(!isWasmInitialized) {
19896 throw new Error("initializeWasm() must be awaited first!");
19898 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
19899 // debug statements here
19901 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19903 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
19904 if(!isWasmInitialized) {
19905 throw new Error("initializeWasm() must be awaited first!");
19907 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
19908 return nativeResponseValue;
19910 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
19912 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
19913 if(!isWasmInitialized) {
19914 throw new Error("initializeWasm() must be awaited first!");
19916 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
19917 // debug statements here
19919 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19921 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
19922 if(!isWasmInitialized) {
19923 throw new Error("initializeWasm() must be awaited first!");
19925 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
19926 return nativeResponseValue;
19928 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
19930 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
19931 if(!isWasmInitialized) {
19932 throw new Error("initializeWasm() must be awaited first!");
19934 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
19935 // debug statements here
19937 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19939 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
19940 if(!isWasmInitialized) {
19941 throw new Error("initializeWasm() must be awaited first!");
19943 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
19944 return nativeResponseValue;
19946 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
19948 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
19949 if(!isWasmInitialized) {
19950 throw new Error("initializeWasm() must be awaited first!");
19952 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
19953 // debug statements here
19955 // 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);
19957 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 {
19958 if(!isWasmInitialized) {
19959 throw new Error("initializeWasm() must be awaited first!");
19961 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
19962 return nativeResponseValue;
19964 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
19966 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
19967 if(!isWasmInitialized) {
19968 throw new Error("initializeWasm() must be awaited first!");
19970 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
19971 return nativeResponseValue;
19973 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
19975 export function ExpandedKey_free(this_obj: number): void {
19976 if(!isWasmInitialized) {
19977 throw new Error("initializeWasm() must be awaited first!");
19979 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
19980 // debug statements here
19982 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
19984 export function ExpandedKey_new(key_material: number): number {
19985 if(!isWasmInitialized) {
19986 throw new Error("initializeWasm() must be awaited first!");
19988 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
19989 return nativeResponseValue;
19991 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ create(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, const struct LDKKeysInterface *NONNULL_PTR keys_manager, uint64_t current_time);
19993 export function create(keys: number, min_value_msat: number, invoice_expiry_delta_secs: number, keys_manager: number, current_time: bigint): number {
19994 if(!isWasmInitialized) {
19995 throw new Error("initializeWasm() must be awaited first!");
19997 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
19998 return nativeResponseValue;
20000 // struct LDKCResult_PaymentSecretNoneZ create_from_hash(const struct LDKExpandedKey *NONNULL_PTR keys, struct LDKCOption_u64Z min_value_msat, struct LDKThirtyTwoBytes payment_hash, uint32_t invoice_expiry_delta_secs, uint64_t current_time);
20002 export function create_from_hash(keys: number, min_value_msat: number, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): number {
20003 if(!isWasmInitialized) {
20004 throw new Error("initializeWasm() must be awaited first!");
20006 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20007 return nativeResponseValue;
20009 // void DecodeError_free(struct LDKDecodeError this_obj);
20011 export function DecodeError_free(this_obj: number): void {
20012 if(!isWasmInitialized) {
20013 throw new Error("initializeWasm() must be awaited first!");
20015 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20016 // debug statements here
20018 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20020 export function DecodeError_clone_ptr(arg: number): number {
20021 if(!isWasmInitialized) {
20022 throw new Error("initializeWasm() must be awaited first!");
20024 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20025 return nativeResponseValue;
20027 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20029 export function DecodeError_clone(orig: number): number {
20030 if(!isWasmInitialized) {
20031 throw new Error("initializeWasm() must be awaited first!");
20033 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20034 return nativeResponseValue;
20036 // void Init_free(struct LDKInit this_obj);
20038 export function Init_free(this_obj: number): void {
20039 if(!isWasmInitialized) {
20040 throw new Error("initializeWasm() must be awaited first!");
20042 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20043 // debug statements here
20045 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20047 export function Init_get_features(this_ptr: number): number {
20048 if(!isWasmInitialized) {
20049 throw new Error("initializeWasm() must be awaited first!");
20051 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20052 return nativeResponseValue;
20054 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20056 export function Init_set_features(this_ptr: number, val: number): void {
20057 if(!isWasmInitialized) {
20058 throw new Error("initializeWasm() must be awaited first!");
20060 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20061 // debug statements here
20063 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20065 export function Init_get_remote_network_address(this_ptr: number): number {
20066 if(!isWasmInitialized) {
20067 throw new Error("initializeWasm() must be awaited first!");
20069 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20070 return nativeResponseValue;
20072 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20074 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
20075 if(!isWasmInitialized) {
20076 throw new Error("initializeWasm() must be awaited first!");
20078 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20079 // debug statements here
20081 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20083 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
20084 if(!isWasmInitialized) {
20085 throw new Error("initializeWasm() must be awaited first!");
20087 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20088 return nativeResponseValue;
20090 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20092 export function Init_clone_ptr(arg: number): number {
20093 if(!isWasmInitialized) {
20094 throw new Error("initializeWasm() must be awaited first!");
20096 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20097 return nativeResponseValue;
20099 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20101 export function Init_clone(orig: number): number {
20102 if(!isWasmInitialized) {
20103 throw new Error("initializeWasm() must be awaited first!");
20105 const nativeResponseValue = wasm.TS_Init_clone(orig);
20106 return nativeResponseValue;
20108 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20110 export function ErrorMessage_free(this_obj: number): void {
20111 if(!isWasmInitialized) {
20112 throw new Error("initializeWasm() must be awaited first!");
20114 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20115 // debug statements here
20117 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20119 export function ErrorMessage_get_channel_id(this_ptr: number): number {
20120 if(!isWasmInitialized) {
20121 throw new Error("initializeWasm() must be awaited first!");
20123 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20124 return nativeResponseValue;
20126 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20128 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
20129 if(!isWasmInitialized) {
20130 throw new Error("initializeWasm() must be awaited first!");
20132 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20133 // debug statements here
20135 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20137 export function ErrorMessage_get_data(this_ptr: number): number {
20138 if(!isWasmInitialized) {
20139 throw new Error("initializeWasm() must be awaited first!");
20141 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20142 return nativeResponseValue;
20144 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20146 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
20147 if(!isWasmInitialized) {
20148 throw new Error("initializeWasm() must be awaited first!");
20150 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20151 // debug statements here
20153 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20155 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
20156 if(!isWasmInitialized) {
20157 throw new Error("initializeWasm() must be awaited first!");
20159 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20160 return nativeResponseValue;
20162 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20164 export function ErrorMessage_clone_ptr(arg: number): number {
20165 if(!isWasmInitialized) {
20166 throw new Error("initializeWasm() must be awaited first!");
20168 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20169 return nativeResponseValue;
20171 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20173 export function ErrorMessage_clone(orig: number): number {
20174 if(!isWasmInitialized) {
20175 throw new Error("initializeWasm() must be awaited first!");
20177 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20178 return nativeResponseValue;
20180 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20182 export function WarningMessage_free(this_obj: number): void {
20183 if(!isWasmInitialized) {
20184 throw new Error("initializeWasm() must be awaited first!");
20186 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20187 // debug statements here
20189 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20191 export function WarningMessage_get_channel_id(this_ptr: number): number {
20192 if(!isWasmInitialized) {
20193 throw new Error("initializeWasm() must be awaited first!");
20195 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20196 return nativeResponseValue;
20198 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20200 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
20201 if(!isWasmInitialized) {
20202 throw new Error("initializeWasm() must be awaited first!");
20204 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20205 // debug statements here
20207 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20209 export function WarningMessage_get_data(this_ptr: number): number {
20210 if(!isWasmInitialized) {
20211 throw new Error("initializeWasm() must be awaited first!");
20213 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
20214 return nativeResponseValue;
20216 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20218 export function WarningMessage_set_data(this_ptr: number, val: number): void {
20219 if(!isWasmInitialized) {
20220 throw new Error("initializeWasm() must be awaited first!");
20222 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
20223 // debug statements here
20225 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20227 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
20228 if(!isWasmInitialized) {
20229 throw new Error("initializeWasm() must be awaited first!");
20231 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
20232 return nativeResponseValue;
20234 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
20236 export function WarningMessage_clone_ptr(arg: number): number {
20237 if(!isWasmInitialized) {
20238 throw new Error("initializeWasm() must be awaited first!");
20240 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
20241 return nativeResponseValue;
20243 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
20245 export function WarningMessage_clone(orig: number): number {
20246 if(!isWasmInitialized) {
20247 throw new Error("initializeWasm() must be awaited first!");
20249 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
20250 return nativeResponseValue;
20252 // void Ping_free(struct LDKPing this_obj);
20254 export function Ping_free(this_obj: number): void {
20255 if(!isWasmInitialized) {
20256 throw new Error("initializeWasm() must be awaited first!");
20258 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
20259 // debug statements here
20261 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
20263 export function Ping_get_ponglen(this_ptr: number): number {
20264 if(!isWasmInitialized) {
20265 throw new Error("initializeWasm() must be awaited first!");
20267 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
20268 return nativeResponseValue;
20270 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20272 export function Ping_set_ponglen(this_ptr: number, val: number): void {
20273 if(!isWasmInitialized) {
20274 throw new Error("initializeWasm() must be awaited first!");
20276 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
20277 // debug statements here
20279 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
20281 export function Ping_get_byteslen(this_ptr: number): number {
20282 if(!isWasmInitialized) {
20283 throw new Error("initializeWasm() must be awaited first!");
20285 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
20286 return nativeResponseValue;
20288 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20290 export function Ping_set_byteslen(this_ptr: number, val: number): void {
20291 if(!isWasmInitialized) {
20292 throw new Error("initializeWasm() must be awaited first!");
20294 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
20295 // debug statements here
20297 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
20299 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
20300 if(!isWasmInitialized) {
20301 throw new Error("initializeWasm() must be awaited first!");
20303 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
20304 return nativeResponseValue;
20306 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
20308 export function Ping_clone_ptr(arg: number): number {
20309 if(!isWasmInitialized) {
20310 throw new Error("initializeWasm() must be awaited first!");
20312 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
20313 return nativeResponseValue;
20315 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
20317 export function Ping_clone(orig: number): number {
20318 if(!isWasmInitialized) {
20319 throw new Error("initializeWasm() must be awaited first!");
20321 const nativeResponseValue = wasm.TS_Ping_clone(orig);
20322 return nativeResponseValue;
20324 // void Pong_free(struct LDKPong this_obj);
20326 export function Pong_free(this_obj: number): void {
20327 if(!isWasmInitialized) {
20328 throw new Error("initializeWasm() must be awaited first!");
20330 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
20331 // debug statements here
20333 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
20335 export function Pong_get_byteslen(this_ptr: number): number {
20336 if(!isWasmInitialized) {
20337 throw new Error("initializeWasm() must be awaited first!");
20339 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
20340 return nativeResponseValue;
20342 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
20344 export function Pong_set_byteslen(this_ptr: number, val: number): void {
20345 if(!isWasmInitialized) {
20346 throw new Error("initializeWasm() must be awaited first!");
20348 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
20349 // debug statements here
20351 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
20353 export function Pong_new(byteslen_arg: number): number {
20354 if(!isWasmInitialized) {
20355 throw new Error("initializeWasm() must be awaited first!");
20357 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
20358 return nativeResponseValue;
20360 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
20362 export function Pong_clone_ptr(arg: number): number {
20363 if(!isWasmInitialized) {
20364 throw new Error("initializeWasm() must be awaited first!");
20366 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
20367 return nativeResponseValue;
20369 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
20371 export function Pong_clone(orig: number): number {
20372 if(!isWasmInitialized) {
20373 throw new Error("initializeWasm() must be awaited first!");
20375 const nativeResponseValue = wasm.TS_Pong_clone(orig);
20376 return nativeResponseValue;
20378 // void OpenChannel_free(struct LDKOpenChannel this_obj);
20380 export function OpenChannel_free(this_obj: number): void {
20381 if(!isWasmInitialized) {
20382 throw new Error("initializeWasm() must be awaited first!");
20384 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
20385 // debug statements here
20387 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20389 export function OpenChannel_get_chain_hash(this_ptr: number): number {
20390 if(!isWasmInitialized) {
20391 throw new Error("initializeWasm() must be awaited first!");
20393 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
20394 return nativeResponseValue;
20396 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20398 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
20399 if(!isWasmInitialized) {
20400 throw new Error("initializeWasm() must be awaited first!");
20402 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
20403 // debug statements here
20405 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20407 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
20408 if(!isWasmInitialized) {
20409 throw new Error("initializeWasm() must be awaited first!");
20411 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
20412 return nativeResponseValue;
20414 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20416 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20417 if(!isWasmInitialized) {
20418 throw new Error("initializeWasm() must be awaited first!");
20420 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
20421 // debug statements here
20423 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20425 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
20426 if(!isWasmInitialized) {
20427 throw new Error("initializeWasm() must be awaited first!");
20429 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
20430 return nativeResponseValue;
20432 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20434 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
20435 if(!isWasmInitialized) {
20436 throw new Error("initializeWasm() must be awaited first!");
20438 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
20439 // debug statements here
20441 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20443 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
20444 if(!isWasmInitialized) {
20445 throw new Error("initializeWasm() must be awaited first!");
20447 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
20448 return nativeResponseValue;
20450 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20452 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
20453 if(!isWasmInitialized) {
20454 throw new Error("initializeWasm() must be awaited first!");
20456 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
20457 // debug statements here
20459 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20461 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20462 if(!isWasmInitialized) {
20463 throw new Error("initializeWasm() must be awaited first!");
20465 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
20466 return nativeResponseValue;
20468 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20470 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20471 if(!isWasmInitialized) {
20472 throw new Error("initializeWasm() must be awaited first!");
20474 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
20475 // debug statements here
20477 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20479 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20480 if(!isWasmInitialized) {
20481 throw new Error("initializeWasm() must be awaited first!");
20483 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20484 return nativeResponseValue;
20486 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20488 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20489 if(!isWasmInitialized) {
20490 throw new Error("initializeWasm() must be awaited first!");
20492 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20493 // debug statements here
20495 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20497 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20498 if(!isWasmInitialized) {
20499 throw new Error("initializeWasm() must be awaited first!");
20501 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
20502 return nativeResponseValue;
20504 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20506 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20507 if(!isWasmInitialized) {
20508 throw new Error("initializeWasm() must be awaited first!");
20510 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
20511 // debug statements here
20513 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20515 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20516 if(!isWasmInitialized) {
20517 throw new Error("initializeWasm() must be awaited first!");
20519 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
20520 return nativeResponseValue;
20522 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20524 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20525 if(!isWasmInitialized) {
20526 throw new Error("initializeWasm() must be awaited first!");
20528 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
20529 // debug statements here
20531 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20533 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
20534 if(!isWasmInitialized) {
20535 throw new Error("initializeWasm() must be awaited first!");
20537 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
20538 return nativeResponseValue;
20540 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
20542 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
20543 if(!isWasmInitialized) {
20544 throw new Error("initializeWasm() must be awaited first!");
20546 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
20547 // debug statements here
20549 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20551 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
20552 if(!isWasmInitialized) {
20553 throw new Error("initializeWasm() must be awaited first!");
20555 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
20556 return nativeResponseValue;
20558 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20560 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
20561 if(!isWasmInitialized) {
20562 throw new Error("initializeWasm() must be awaited first!");
20564 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
20565 // debug statements here
20567 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20569 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
20570 if(!isWasmInitialized) {
20571 throw new Error("initializeWasm() must be awaited first!");
20573 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
20574 return nativeResponseValue;
20576 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20578 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20579 if(!isWasmInitialized) {
20580 throw new Error("initializeWasm() must be awaited first!");
20582 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
20583 // debug statements here
20585 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20587 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
20588 if(!isWasmInitialized) {
20589 throw new Error("initializeWasm() must be awaited first!");
20591 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
20592 return nativeResponseValue;
20594 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20596 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20597 if(!isWasmInitialized) {
20598 throw new Error("initializeWasm() must be awaited first!");
20600 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
20601 // debug statements here
20603 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20605 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
20606 if(!isWasmInitialized) {
20607 throw new Error("initializeWasm() must be awaited first!");
20609 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
20610 return nativeResponseValue;
20612 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20614 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20615 if(!isWasmInitialized) {
20616 throw new Error("initializeWasm() must be awaited first!");
20618 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
20619 // debug statements here
20621 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20623 export function OpenChannel_get_payment_point(this_ptr: number): number {
20624 if(!isWasmInitialized) {
20625 throw new Error("initializeWasm() must be awaited first!");
20627 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
20628 return nativeResponseValue;
20630 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20632 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
20633 if(!isWasmInitialized) {
20634 throw new Error("initializeWasm() must be awaited first!");
20636 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
20637 // debug statements here
20639 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20641 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20642 if(!isWasmInitialized) {
20643 throw new Error("initializeWasm() must be awaited first!");
20645 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
20646 return nativeResponseValue;
20648 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20650 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20651 if(!isWasmInitialized) {
20652 throw new Error("initializeWasm() must be awaited first!");
20654 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
20655 // debug statements here
20657 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20659 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
20660 if(!isWasmInitialized) {
20661 throw new Error("initializeWasm() must be awaited first!");
20663 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
20664 return nativeResponseValue;
20666 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20668 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20669 if(!isWasmInitialized) {
20670 throw new Error("initializeWasm() must be awaited first!");
20672 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
20673 // debug statements here
20675 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20677 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
20678 if(!isWasmInitialized) {
20679 throw new Error("initializeWasm() must be awaited first!");
20681 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
20682 return nativeResponseValue;
20684 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20686 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20687 if(!isWasmInitialized) {
20688 throw new Error("initializeWasm() must be awaited first!");
20690 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
20691 // debug statements here
20693 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20695 export function OpenChannel_get_channel_flags(this_ptr: number): number {
20696 if(!isWasmInitialized) {
20697 throw new Error("initializeWasm() must be awaited first!");
20699 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
20700 return nativeResponseValue;
20702 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
20704 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
20705 if(!isWasmInitialized) {
20706 throw new Error("initializeWasm() must be awaited first!");
20708 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
20709 // debug statements here
20711 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20713 export function OpenChannel_get_channel_type(this_ptr: number): number {
20714 if(!isWasmInitialized) {
20715 throw new Error("initializeWasm() must be awaited first!");
20717 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
20718 return nativeResponseValue;
20720 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20722 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
20723 if(!isWasmInitialized) {
20724 throw new Error("initializeWasm() must be awaited first!");
20726 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
20727 // debug statements here
20729 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
20731 export function OpenChannel_clone_ptr(arg: number): number {
20732 if(!isWasmInitialized) {
20733 throw new Error("initializeWasm() must be awaited first!");
20735 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
20736 return nativeResponseValue;
20738 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
20740 export function OpenChannel_clone(orig: number): number {
20741 if(!isWasmInitialized) {
20742 throw new Error("initializeWasm() must be awaited first!");
20744 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
20745 return nativeResponseValue;
20747 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
20749 export function AcceptChannel_free(this_obj: number): void {
20750 if(!isWasmInitialized) {
20751 throw new Error("initializeWasm() must be awaited first!");
20753 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
20754 // debug statements here
20756 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
20758 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
20759 if(!isWasmInitialized) {
20760 throw new Error("initializeWasm() must be awaited first!");
20762 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
20763 return nativeResponseValue;
20765 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20767 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20768 if(!isWasmInitialized) {
20769 throw new Error("initializeWasm() must be awaited first!");
20771 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
20772 // debug statements here
20774 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20776 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20777 if(!isWasmInitialized) {
20778 throw new Error("initializeWasm() must be awaited first!");
20780 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
20781 return nativeResponseValue;
20783 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20785 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20786 if(!isWasmInitialized) {
20787 throw new Error("initializeWasm() must be awaited first!");
20789 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
20790 // debug statements here
20792 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20794 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20795 if(!isWasmInitialized) {
20796 throw new Error("initializeWasm() must be awaited first!");
20798 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20799 return nativeResponseValue;
20801 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20803 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20804 if(!isWasmInitialized) {
20805 throw new Error("initializeWasm() must be awaited first!");
20807 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20808 // debug statements here
20810 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20812 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20813 if(!isWasmInitialized) {
20814 throw new Error("initializeWasm() must be awaited first!");
20816 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
20817 return nativeResponseValue;
20819 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20821 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20822 if(!isWasmInitialized) {
20823 throw new Error("initializeWasm() must be awaited first!");
20825 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
20826 // debug statements here
20828 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20830 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20831 if(!isWasmInitialized) {
20832 throw new Error("initializeWasm() must be awaited first!");
20834 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
20835 return nativeResponseValue;
20837 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20839 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20840 if(!isWasmInitialized) {
20841 throw new Error("initializeWasm() must be awaited first!");
20843 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
20844 // debug statements here
20846 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20848 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
20849 if(!isWasmInitialized) {
20850 throw new Error("initializeWasm() must be awaited first!");
20852 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
20853 return nativeResponseValue;
20855 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
20857 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
20858 if(!isWasmInitialized) {
20859 throw new Error("initializeWasm() must be awaited first!");
20861 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
20862 // debug statements here
20864 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20866 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
20867 if(!isWasmInitialized) {
20868 throw new Error("initializeWasm() must be awaited first!");
20870 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
20871 return nativeResponseValue;
20873 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20875 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
20876 if(!isWasmInitialized) {
20877 throw new Error("initializeWasm() must be awaited first!");
20879 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
20880 // debug statements here
20882 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20884 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
20885 if(!isWasmInitialized) {
20886 throw new Error("initializeWasm() must be awaited first!");
20888 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
20889 return nativeResponseValue;
20891 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20893 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20894 if(!isWasmInitialized) {
20895 throw new Error("initializeWasm() must be awaited first!");
20897 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
20898 // debug statements here
20900 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20902 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
20903 if(!isWasmInitialized) {
20904 throw new Error("initializeWasm() must be awaited first!");
20906 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
20907 return nativeResponseValue;
20909 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20911 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20912 if(!isWasmInitialized) {
20913 throw new Error("initializeWasm() must be awaited first!");
20915 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
20916 // debug statements here
20918 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20920 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
20921 if(!isWasmInitialized) {
20922 throw new Error("initializeWasm() must be awaited first!");
20924 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
20925 return nativeResponseValue;
20927 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20929 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20930 if(!isWasmInitialized) {
20931 throw new Error("initializeWasm() must be awaited first!");
20933 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
20934 // debug statements here
20936 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20938 export function AcceptChannel_get_payment_point(this_ptr: number): number {
20939 if(!isWasmInitialized) {
20940 throw new Error("initializeWasm() must be awaited first!");
20942 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
20943 return nativeResponseValue;
20945 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20947 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
20948 if(!isWasmInitialized) {
20949 throw new Error("initializeWasm() must be awaited first!");
20951 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
20952 // debug statements here
20954 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20956 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20957 if(!isWasmInitialized) {
20958 throw new Error("initializeWasm() must be awaited first!");
20960 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
20961 return nativeResponseValue;
20963 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20965 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20966 if(!isWasmInitialized) {
20967 throw new Error("initializeWasm() must be awaited first!");
20969 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
20970 // debug statements here
20972 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20974 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
20975 if(!isWasmInitialized) {
20976 throw new Error("initializeWasm() must be awaited first!");
20978 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
20979 return nativeResponseValue;
20981 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20983 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20984 if(!isWasmInitialized) {
20985 throw new Error("initializeWasm() must be awaited first!");
20987 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
20988 // debug statements here
20990 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20992 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
20993 if(!isWasmInitialized) {
20994 throw new Error("initializeWasm() must be awaited first!");
20996 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
20997 return nativeResponseValue;
20999 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21001 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21002 if(!isWasmInitialized) {
21003 throw new Error("initializeWasm() must be awaited first!");
21005 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21006 // debug statements here
21008 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21010 export function AcceptChannel_get_channel_type(this_ptr: number): number {
21011 if(!isWasmInitialized) {
21012 throw new Error("initializeWasm() must be awaited first!");
21014 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21015 return nativeResponseValue;
21017 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21019 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
21020 if(!isWasmInitialized) {
21021 throw new Error("initializeWasm() must be awaited first!");
21023 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21024 // debug statements here
21026 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21028 export function AcceptChannel_clone_ptr(arg: number): number {
21029 if(!isWasmInitialized) {
21030 throw new Error("initializeWasm() must be awaited first!");
21032 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21033 return nativeResponseValue;
21035 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21037 export function AcceptChannel_clone(orig: number): number {
21038 if(!isWasmInitialized) {
21039 throw new Error("initializeWasm() must be awaited first!");
21041 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21042 return nativeResponseValue;
21044 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21046 export function FundingCreated_free(this_obj: number): void {
21047 if(!isWasmInitialized) {
21048 throw new Error("initializeWasm() must be awaited first!");
21050 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21051 // debug statements here
21053 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21055 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
21056 if(!isWasmInitialized) {
21057 throw new Error("initializeWasm() must be awaited first!");
21059 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21060 return nativeResponseValue;
21062 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21064 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
21065 if(!isWasmInitialized) {
21066 throw new Error("initializeWasm() must be awaited first!");
21068 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21069 // debug statements here
21071 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21073 export function FundingCreated_get_funding_txid(this_ptr: number): number {
21074 if(!isWasmInitialized) {
21075 throw new Error("initializeWasm() must be awaited first!");
21077 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21078 return nativeResponseValue;
21080 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21082 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
21083 if(!isWasmInitialized) {
21084 throw new Error("initializeWasm() must be awaited first!");
21086 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21087 // debug statements here
21089 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21091 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
21092 if(!isWasmInitialized) {
21093 throw new Error("initializeWasm() must be awaited first!");
21095 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21096 return nativeResponseValue;
21098 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21100 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
21101 if(!isWasmInitialized) {
21102 throw new Error("initializeWasm() must be awaited first!");
21104 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21105 // debug statements here
21107 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21109 export function FundingCreated_get_signature(this_ptr: number): number {
21110 if(!isWasmInitialized) {
21111 throw new Error("initializeWasm() must be awaited first!");
21113 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21114 return nativeResponseValue;
21116 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21118 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
21119 if(!isWasmInitialized) {
21120 throw new Error("initializeWasm() must be awaited first!");
21122 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21123 // debug statements here
21125 // 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);
21127 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
21128 if(!isWasmInitialized) {
21129 throw new Error("initializeWasm() must be awaited first!");
21131 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21132 return nativeResponseValue;
21134 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21136 export function FundingCreated_clone_ptr(arg: number): number {
21137 if(!isWasmInitialized) {
21138 throw new Error("initializeWasm() must be awaited first!");
21140 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21141 return nativeResponseValue;
21143 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21145 export function FundingCreated_clone(orig: number): number {
21146 if(!isWasmInitialized) {
21147 throw new Error("initializeWasm() must be awaited first!");
21149 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21150 return nativeResponseValue;
21152 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21154 export function FundingSigned_free(this_obj: number): void {
21155 if(!isWasmInitialized) {
21156 throw new Error("initializeWasm() must be awaited first!");
21158 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21159 // debug statements here
21161 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21163 export function FundingSigned_get_channel_id(this_ptr: number): number {
21164 if(!isWasmInitialized) {
21165 throw new Error("initializeWasm() must be awaited first!");
21167 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21168 return nativeResponseValue;
21170 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21172 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
21173 if(!isWasmInitialized) {
21174 throw new Error("initializeWasm() must be awaited first!");
21176 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21177 // debug statements here
21179 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21181 export function FundingSigned_get_signature(this_ptr: number): number {
21182 if(!isWasmInitialized) {
21183 throw new Error("initializeWasm() must be awaited first!");
21185 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21186 return nativeResponseValue;
21188 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21190 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
21191 if(!isWasmInitialized) {
21192 throw new Error("initializeWasm() must be awaited first!");
21194 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21195 // debug statements here
21197 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21199 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
21200 if(!isWasmInitialized) {
21201 throw new Error("initializeWasm() must be awaited first!");
21203 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21204 return nativeResponseValue;
21206 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21208 export function FundingSigned_clone_ptr(arg: number): number {
21209 if(!isWasmInitialized) {
21210 throw new Error("initializeWasm() must be awaited first!");
21212 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
21213 return nativeResponseValue;
21215 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
21217 export function FundingSigned_clone(orig: number): number {
21218 if(!isWasmInitialized) {
21219 throw new Error("initializeWasm() must be awaited first!");
21221 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
21222 return nativeResponseValue;
21224 // void ChannelReady_free(struct LDKChannelReady this_obj);
21226 export function ChannelReady_free(this_obj: number): void {
21227 if(!isWasmInitialized) {
21228 throw new Error("initializeWasm() must be awaited first!");
21230 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
21231 // debug statements here
21233 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
21235 export function ChannelReady_get_channel_id(this_ptr: number): number {
21236 if(!isWasmInitialized) {
21237 throw new Error("initializeWasm() must be awaited first!");
21239 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
21240 return nativeResponseValue;
21242 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21244 export function ChannelReady_set_channel_id(this_ptr: number, val: number): void {
21245 if(!isWasmInitialized) {
21246 throw new Error("initializeWasm() must be awaited first!");
21248 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
21249 // debug statements here
21251 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21253 export function ChannelReady_get_next_per_commitment_point(this_ptr: number): number {
21254 if(!isWasmInitialized) {
21255 throw new Error("initializeWasm() must be awaited first!");
21257 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
21258 return nativeResponseValue;
21260 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21262 export function ChannelReady_set_next_per_commitment_point(this_ptr: number, val: number): void {
21263 if(!isWasmInitialized) {
21264 throw new Error("initializeWasm() must be awaited first!");
21266 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
21267 // debug statements here
21269 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21271 export function ChannelReady_get_short_channel_id_alias(this_ptr: number): number {
21272 if(!isWasmInitialized) {
21273 throw new Error("initializeWasm() must be awaited first!");
21275 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
21276 return nativeResponseValue;
21278 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21280 export function ChannelReady_set_short_channel_id_alias(this_ptr: number, val: number): void {
21281 if(!isWasmInitialized) {
21282 throw new Error("initializeWasm() must be awaited first!");
21284 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
21285 // debug statements here
21287 // MUST_USE_RES struct LDKChannelReady ChannelReady_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg, struct LDKCOption_u64Z short_channel_id_alias_arg);
21289 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
21290 if(!isWasmInitialized) {
21291 throw new Error("initializeWasm() must be awaited first!");
21293 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
21294 return nativeResponseValue;
21296 // uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
21298 export function ChannelReady_clone_ptr(arg: number): number {
21299 if(!isWasmInitialized) {
21300 throw new Error("initializeWasm() must be awaited first!");
21302 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
21303 return nativeResponseValue;
21305 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
21307 export function ChannelReady_clone(orig: number): number {
21308 if(!isWasmInitialized) {
21309 throw new Error("initializeWasm() must be awaited first!");
21311 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
21312 return nativeResponseValue;
21314 // void Shutdown_free(struct LDKShutdown this_obj);
21316 export function Shutdown_free(this_obj: number): void {
21317 if(!isWasmInitialized) {
21318 throw new Error("initializeWasm() must be awaited first!");
21320 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
21321 // debug statements here
21323 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
21325 export function Shutdown_get_channel_id(this_ptr: number): number {
21326 if(!isWasmInitialized) {
21327 throw new Error("initializeWasm() must be awaited first!");
21329 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
21330 return nativeResponseValue;
21332 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21334 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
21335 if(!isWasmInitialized) {
21336 throw new Error("initializeWasm() must be awaited first!");
21338 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
21339 // debug statements here
21341 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
21343 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
21344 if(!isWasmInitialized) {
21345 throw new Error("initializeWasm() must be awaited first!");
21347 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
21348 return nativeResponseValue;
21350 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
21352 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
21353 if(!isWasmInitialized) {
21354 throw new Error("initializeWasm() must be awaited first!");
21356 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
21357 // debug statements here
21359 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
21361 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
21362 if(!isWasmInitialized) {
21363 throw new Error("initializeWasm() must be awaited first!");
21365 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
21366 return nativeResponseValue;
21368 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
21370 export function Shutdown_clone_ptr(arg: number): number {
21371 if(!isWasmInitialized) {
21372 throw new Error("initializeWasm() must be awaited first!");
21374 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
21375 return nativeResponseValue;
21377 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
21379 export function Shutdown_clone(orig: number): number {
21380 if(!isWasmInitialized) {
21381 throw new Error("initializeWasm() must be awaited first!");
21383 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
21384 return nativeResponseValue;
21386 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
21388 export function ClosingSignedFeeRange_free(this_obj: number): void {
21389 if(!isWasmInitialized) {
21390 throw new Error("initializeWasm() must be awaited first!");
21392 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
21393 // debug statements here
21395 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21397 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
21398 if(!isWasmInitialized) {
21399 throw new Error("initializeWasm() must be awaited first!");
21401 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
21402 return nativeResponseValue;
21404 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21406 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
21407 if(!isWasmInitialized) {
21408 throw new Error("initializeWasm() must be awaited first!");
21410 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
21411 // debug statements here
21413 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21415 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
21416 if(!isWasmInitialized) {
21417 throw new Error("initializeWasm() must be awaited first!");
21419 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
21420 return nativeResponseValue;
21422 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21424 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
21425 if(!isWasmInitialized) {
21426 throw new Error("initializeWasm() must be awaited first!");
21428 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
21429 // debug statements here
21431 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
21433 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
21434 if(!isWasmInitialized) {
21435 throw new Error("initializeWasm() must be awaited first!");
21437 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
21438 return nativeResponseValue;
21440 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
21442 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
21443 if(!isWasmInitialized) {
21444 throw new Error("initializeWasm() must be awaited first!");
21446 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
21447 return nativeResponseValue;
21449 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
21451 export function ClosingSignedFeeRange_clone(orig: number): number {
21452 if(!isWasmInitialized) {
21453 throw new Error("initializeWasm() must be awaited first!");
21455 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
21456 return nativeResponseValue;
21458 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
21460 export function ClosingSigned_free(this_obj: number): void {
21461 if(!isWasmInitialized) {
21462 throw new Error("initializeWasm() must be awaited first!");
21464 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
21465 // debug statements here
21467 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
21469 export function ClosingSigned_get_channel_id(this_ptr: number): number {
21470 if(!isWasmInitialized) {
21471 throw new Error("initializeWasm() must be awaited first!");
21473 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
21474 return nativeResponseValue;
21476 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21478 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
21479 if(!isWasmInitialized) {
21480 throw new Error("initializeWasm() must be awaited first!");
21482 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
21483 // debug statements here
21485 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21487 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
21488 if(!isWasmInitialized) {
21489 throw new Error("initializeWasm() must be awaited first!");
21491 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
21492 return nativeResponseValue;
21494 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
21496 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
21497 if(!isWasmInitialized) {
21498 throw new Error("initializeWasm() must be awaited first!");
21500 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
21501 // debug statements here
21503 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21505 export function ClosingSigned_get_signature(this_ptr: number): number {
21506 if(!isWasmInitialized) {
21507 throw new Error("initializeWasm() must be awaited first!");
21509 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
21510 return nativeResponseValue;
21512 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21514 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
21515 if(!isWasmInitialized) {
21516 throw new Error("initializeWasm() must be awaited first!");
21518 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
21519 // debug statements here
21521 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21523 export function ClosingSigned_get_fee_range(this_ptr: number): number {
21524 if(!isWasmInitialized) {
21525 throw new Error("initializeWasm() must be awaited first!");
21527 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
21528 return nativeResponseValue;
21530 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
21532 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
21533 if(!isWasmInitialized) {
21534 throw new Error("initializeWasm() must be awaited first!");
21536 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
21537 // debug statements here
21539 // 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);
21541 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
21542 if(!isWasmInitialized) {
21543 throw new Error("initializeWasm() must be awaited first!");
21545 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
21546 return nativeResponseValue;
21548 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
21550 export function ClosingSigned_clone_ptr(arg: number): number {
21551 if(!isWasmInitialized) {
21552 throw new Error("initializeWasm() must be awaited first!");
21554 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
21555 return nativeResponseValue;
21557 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
21559 export function ClosingSigned_clone(orig: number): number {
21560 if(!isWasmInitialized) {
21561 throw new Error("initializeWasm() must be awaited first!");
21563 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
21564 return nativeResponseValue;
21566 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
21568 export function UpdateAddHTLC_free(this_obj: number): void {
21569 if(!isWasmInitialized) {
21570 throw new Error("initializeWasm() must be awaited first!");
21572 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
21573 // debug statements here
21575 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21577 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
21578 if(!isWasmInitialized) {
21579 throw new Error("initializeWasm() must be awaited first!");
21581 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
21582 return nativeResponseValue;
21584 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21586 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
21587 if(!isWasmInitialized) {
21588 throw new Error("initializeWasm() must be awaited first!");
21590 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
21591 // debug statements here
21593 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21595 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
21596 if(!isWasmInitialized) {
21597 throw new Error("initializeWasm() must be awaited first!");
21599 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
21600 return nativeResponseValue;
21602 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21604 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21605 if(!isWasmInitialized) {
21606 throw new Error("initializeWasm() must be awaited first!");
21608 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
21609 // debug statements here
21611 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21613 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
21614 if(!isWasmInitialized) {
21615 throw new Error("initializeWasm() must be awaited first!");
21617 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
21618 return nativeResponseValue;
21620 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21622 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
21623 if(!isWasmInitialized) {
21624 throw new Error("initializeWasm() must be awaited first!");
21626 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
21627 // debug statements here
21629 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21631 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
21632 if(!isWasmInitialized) {
21633 throw new Error("initializeWasm() must be awaited first!");
21635 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
21636 return nativeResponseValue;
21638 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21640 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
21641 if(!isWasmInitialized) {
21642 throw new Error("initializeWasm() must be awaited first!");
21644 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
21645 // debug statements here
21647 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21649 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
21650 if(!isWasmInitialized) {
21651 throw new Error("initializeWasm() must be awaited first!");
21653 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
21654 return nativeResponseValue;
21656 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
21658 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
21659 if(!isWasmInitialized) {
21660 throw new Error("initializeWasm() must be awaited first!");
21662 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
21663 // debug statements here
21665 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
21667 export function UpdateAddHTLC_clone_ptr(arg: number): number {
21668 if(!isWasmInitialized) {
21669 throw new Error("initializeWasm() must be awaited first!");
21671 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
21672 return nativeResponseValue;
21674 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
21676 export function UpdateAddHTLC_clone(orig: number): number {
21677 if(!isWasmInitialized) {
21678 throw new Error("initializeWasm() must be awaited first!");
21680 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
21681 return nativeResponseValue;
21683 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
21685 export function UpdateFulfillHTLC_free(this_obj: number): void {
21686 if(!isWasmInitialized) {
21687 throw new Error("initializeWasm() must be awaited first!");
21689 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
21690 // debug statements here
21692 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21694 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
21695 if(!isWasmInitialized) {
21696 throw new Error("initializeWasm() must be awaited first!");
21698 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
21699 return nativeResponseValue;
21701 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21703 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
21704 if(!isWasmInitialized) {
21705 throw new Error("initializeWasm() must be awaited first!");
21707 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
21708 // debug statements here
21710 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
21712 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
21713 if(!isWasmInitialized) {
21714 throw new Error("initializeWasm() must be awaited first!");
21716 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
21717 return nativeResponseValue;
21719 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
21721 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21722 if(!isWasmInitialized) {
21723 throw new Error("initializeWasm() must be awaited first!");
21725 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
21726 // debug statements here
21728 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21730 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
21731 if(!isWasmInitialized) {
21732 throw new Error("initializeWasm() must be awaited first!");
21734 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
21735 return nativeResponseValue;
21737 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21739 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
21740 if(!isWasmInitialized) {
21741 throw new Error("initializeWasm() must be awaited first!");
21743 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
21744 // debug statements here
21746 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
21748 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
21749 if(!isWasmInitialized) {
21750 throw new Error("initializeWasm() must be awaited first!");
21752 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
21753 return nativeResponseValue;
21755 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
21757 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
21758 if(!isWasmInitialized) {
21759 throw new Error("initializeWasm() must be awaited first!");
21761 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
21762 return nativeResponseValue;
21764 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
21766 export function UpdateFulfillHTLC_clone(orig: number): number {
21767 if(!isWasmInitialized) {
21768 throw new Error("initializeWasm() must be awaited first!");
21770 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
21771 return nativeResponseValue;
21773 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
21775 export function UpdateFailHTLC_free(this_obj: number): void {
21776 if(!isWasmInitialized) {
21777 throw new Error("initializeWasm() must be awaited first!");
21779 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
21780 // debug statements here
21782 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
21784 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
21785 if(!isWasmInitialized) {
21786 throw new Error("initializeWasm() must be awaited first!");
21788 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
21789 return nativeResponseValue;
21791 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21793 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
21794 if(!isWasmInitialized) {
21795 throw new Error("initializeWasm() must be awaited first!");
21797 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
21798 // debug statements here
21800 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
21802 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
21803 if(!isWasmInitialized) {
21804 throw new Error("initializeWasm() must be awaited first!");
21806 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
21807 return nativeResponseValue;
21809 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
21811 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21812 if(!isWasmInitialized) {
21813 throw new Error("initializeWasm() must be awaited first!");
21815 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
21816 // debug statements here
21818 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
21820 export function UpdateFailHTLC_clone_ptr(arg: number): number {
21821 if(!isWasmInitialized) {
21822 throw new Error("initializeWasm() must be awaited first!");
21824 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
21825 return nativeResponseValue;
21827 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
21829 export function UpdateFailHTLC_clone(orig: number): number {
21830 if(!isWasmInitialized) {
21831 throw new Error("initializeWasm() must be awaited first!");
21833 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
21834 return nativeResponseValue;
21836 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
21838 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
21839 if(!isWasmInitialized) {
21840 throw new Error("initializeWasm() must be awaited first!");
21842 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
21843 // debug statements here
21845 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
21847 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
21848 if(!isWasmInitialized) {
21849 throw new Error("initializeWasm() must be awaited first!");
21851 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
21852 return nativeResponseValue;
21854 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21856 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
21857 if(!isWasmInitialized) {
21858 throw new Error("initializeWasm() must be awaited first!");
21860 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
21861 // debug statements here
21863 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21865 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
21866 if(!isWasmInitialized) {
21867 throw new Error("initializeWasm() must be awaited first!");
21869 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
21870 return nativeResponseValue;
21872 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
21874 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21875 if(!isWasmInitialized) {
21876 throw new Error("initializeWasm() must be awaited first!");
21878 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
21879 // debug statements here
21881 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21883 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
21884 if(!isWasmInitialized) {
21885 throw new Error("initializeWasm() must be awaited first!");
21887 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
21888 return nativeResponseValue;
21890 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
21892 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
21893 if(!isWasmInitialized) {
21894 throw new Error("initializeWasm() must be awaited first!");
21896 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
21897 // debug statements here
21899 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
21901 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
21902 if(!isWasmInitialized) {
21903 throw new Error("initializeWasm() must be awaited first!");
21905 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
21906 return nativeResponseValue;
21908 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
21910 export function UpdateFailMalformedHTLC_clone(orig: number): number {
21911 if(!isWasmInitialized) {
21912 throw new Error("initializeWasm() must be awaited first!");
21914 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
21915 return nativeResponseValue;
21917 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
21919 export function CommitmentSigned_free(this_obj: number): void {
21920 if(!isWasmInitialized) {
21921 throw new Error("initializeWasm() must be awaited first!");
21923 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
21924 // debug statements here
21926 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
21928 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
21929 if(!isWasmInitialized) {
21930 throw new Error("initializeWasm() must be awaited first!");
21932 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
21933 return nativeResponseValue;
21935 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21937 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
21938 if(!isWasmInitialized) {
21939 throw new Error("initializeWasm() must be awaited first!");
21941 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
21942 // debug statements here
21944 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
21946 export function CommitmentSigned_get_signature(this_ptr: number): number {
21947 if(!isWasmInitialized) {
21948 throw new Error("initializeWasm() must be awaited first!");
21950 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
21951 return nativeResponseValue;
21953 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21955 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
21956 if(!isWasmInitialized) {
21957 throw new Error("initializeWasm() must be awaited first!");
21959 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
21960 // debug statements here
21962 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
21964 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
21965 if(!isWasmInitialized) {
21966 throw new Error("initializeWasm() must be awaited first!");
21968 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
21969 // debug statements here
21971 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
21973 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
21974 if(!isWasmInitialized) {
21975 throw new Error("initializeWasm() must be awaited first!");
21977 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
21978 return nativeResponseValue;
21980 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
21982 export function CommitmentSigned_clone_ptr(arg: number): number {
21983 if(!isWasmInitialized) {
21984 throw new Error("initializeWasm() must be awaited first!");
21986 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
21987 return nativeResponseValue;
21989 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
21991 export function CommitmentSigned_clone(orig: number): number {
21992 if(!isWasmInitialized) {
21993 throw new Error("initializeWasm() must be awaited first!");
21995 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
21996 return nativeResponseValue;
21998 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
22000 export function RevokeAndACK_free(this_obj: number): void {
22001 if(!isWasmInitialized) {
22002 throw new Error("initializeWasm() must be awaited first!");
22004 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22005 // debug statements here
22007 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22009 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
22010 if(!isWasmInitialized) {
22011 throw new Error("initializeWasm() must be awaited first!");
22013 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22014 return nativeResponseValue;
22016 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22018 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
22019 if(!isWasmInitialized) {
22020 throw new Error("initializeWasm() must be awaited first!");
22022 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22023 // debug statements here
22025 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22027 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
22028 if(!isWasmInitialized) {
22029 throw new Error("initializeWasm() must be awaited first!");
22031 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22032 return nativeResponseValue;
22034 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22036 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
22037 if(!isWasmInitialized) {
22038 throw new Error("initializeWasm() must be awaited first!");
22040 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22041 // debug statements here
22043 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22045 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
22046 if(!isWasmInitialized) {
22047 throw new Error("initializeWasm() must be awaited first!");
22049 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22050 return nativeResponseValue;
22052 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22054 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
22055 if(!isWasmInitialized) {
22056 throw new Error("initializeWasm() must be awaited first!");
22058 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22059 // debug statements here
22061 // 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);
22063 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
22064 if(!isWasmInitialized) {
22065 throw new Error("initializeWasm() must be awaited first!");
22067 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22068 return nativeResponseValue;
22070 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22072 export function RevokeAndACK_clone_ptr(arg: number): number {
22073 if(!isWasmInitialized) {
22074 throw new Error("initializeWasm() must be awaited first!");
22076 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22077 return nativeResponseValue;
22079 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22081 export function RevokeAndACK_clone(orig: number): number {
22082 if(!isWasmInitialized) {
22083 throw new Error("initializeWasm() must be awaited first!");
22085 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22086 return nativeResponseValue;
22088 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22090 export function UpdateFee_free(this_obj: number): void {
22091 if(!isWasmInitialized) {
22092 throw new Error("initializeWasm() must be awaited first!");
22094 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22095 // debug statements here
22097 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22099 export function UpdateFee_get_channel_id(this_ptr: number): number {
22100 if(!isWasmInitialized) {
22101 throw new Error("initializeWasm() must be awaited first!");
22103 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22104 return nativeResponseValue;
22106 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22108 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
22109 if(!isWasmInitialized) {
22110 throw new Error("initializeWasm() must be awaited first!");
22112 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22113 // debug statements here
22115 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22117 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
22118 if(!isWasmInitialized) {
22119 throw new Error("initializeWasm() must be awaited first!");
22121 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22122 return nativeResponseValue;
22124 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22126 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
22127 if(!isWasmInitialized) {
22128 throw new Error("initializeWasm() must be awaited first!");
22130 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22131 // debug statements here
22133 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22135 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
22136 if(!isWasmInitialized) {
22137 throw new Error("initializeWasm() must be awaited first!");
22139 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22140 return nativeResponseValue;
22142 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22144 export function UpdateFee_clone_ptr(arg: number): number {
22145 if(!isWasmInitialized) {
22146 throw new Error("initializeWasm() must be awaited first!");
22148 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22149 return nativeResponseValue;
22151 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22153 export function UpdateFee_clone(orig: number): number {
22154 if(!isWasmInitialized) {
22155 throw new Error("initializeWasm() must be awaited first!");
22157 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22158 return nativeResponseValue;
22160 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22162 export function DataLossProtect_free(this_obj: number): void {
22163 if(!isWasmInitialized) {
22164 throw new Error("initializeWasm() must be awaited first!");
22166 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22167 // debug statements here
22169 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22171 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
22172 if(!isWasmInitialized) {
22173 throw new Error("initializeWasm() must be awaited first!");
22175 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22176 return nativeResponseValue;
22178 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22180 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
22181 if(!isWasmInitialized) {
22182 throw new Error("initializeWasm() must be awaited first!");
22184 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22185 // debug statements here
22187 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22189 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
22190 if(!isWasmInitialized) {
22191 throw new Error("initializeWasm() must be awaited first!");
22193 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22194 return nativeResponseValue;
22196 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22198 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
22199 if(!isWasmInitialized) {
22200 throw new Error("initializeWasm() must be awaited first!");
22202 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
22203 // debug statements here
22205 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
22207 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
22208 if(!isWasmInitialized) {
22209 throw new Error("initializeWasm() must be awaited first!");
22211 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
22212 return nativeResponseValue;
22214 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
22216 export function DataLossProtect_clone_ptr(arg: number): number {
22217 if(!isWasmInitialized) {
22218 throw new Error("initializeWasm() must be awaited first!");
22220 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
22221 return nativeResponseValue;
22223 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
22225 export function DataLossProtect_clone(orig: number): number {
22226 if(!isWasmInitialized) {
22227 throw new Error("initializeWasm() must be awaited first!");
22229 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
22230 return nativeResponseValue;
22232 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
22234 export function ChannelReestablish_free(this_obj: number): void {
22235 if(!isWasmInitialized) {
22236 throw new Error("initializeWasm() must be awaited first!");
22238 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
22239 // debug statements here
22241 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
22243 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
22244 if(!isWasmInitialized) {
22245 throw new Error("initializeWasm() must be awaited first!");
22247 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
22248 return nativeResponseValue;
22250 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22252 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
22253 if(!isWasmInitialized) {
22254 throw new Error("initializeWasm() must be awaited first!");
22256 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
22257 // debug statements here
22259 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22261 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
22262 if(!isWasmInitialized) {
22263 throw new Error("initializeWasm() must be awaited first!");
22265 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
22266 return nativeResponseValue;
22268 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22270 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
22271 if(!isWasmInitialized) {
22272 throw new Error("initializeWasm() must be awaited first!");
22274 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
22275 // debug statements here
22277 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22279 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
22280 if(!isWasmInitialized) {
22281 throw new Error("initializeWasm() must be awaited first!");
22283 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
22284 return nativeResponseValue;
22286 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22288 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
22289 if(!isWasmInitialized) {
22290 throw new Error("initializeWasm() must be awaited first!");
22292 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
22293 // debug statements here
22295 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
22297 export function ChannelReestablish_clone_ptr(arg: number): number {
22298 if(!isWasmInitialized) {
22299 throw new Error("initializeWasm() must be awaited first!");
22301 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
22302 return nativeResponseValue;
22304 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
22306 export function ChannelReestablish_clone(orig: number): number {
22307 if(!isWasmInitialized) {
22308 throw new Error("initializeWasm() must be awaited first!");
22310 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
22311 return nativeResponseValue;
22313 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
22315 export function AnnouncementSignatures_free(this_obj: number): void {
22316 if(!isWasmInitialized) {
22317 throw new Error("initializeWasm() must be awaited first!");
22319 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
22320 // debug statements here
22322 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
22324 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
22325 if(!isWasmInitialized) {
22326 throw new Error("initializeWasm() must be awaited first!");
22328 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
22329 return nativeResponseValue;
22331 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22333 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
22334 if(!isWasmInitialized) {
22335 throw new Error("initializeWasm() must be awaited first!");
22337 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
22338 // debug statements here
22340 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22342 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
22343 if(!isWasmInitialized) {
22344 throw new Error("initializeWasm() must be awaited first!");
22346 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
22347 return nativeResponseValue;
22349 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
22351 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
22352 if(!isWasmInitialized) {
22353 throw new Error("initializeWasm() must be awaited first!");
22355 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
22356 // debug statements here
22358 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22360 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
22361 if(!isWasmInitialized) {
22362 throw new Error("initializeWasm() must be awaited first!");
22364 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
22365 return nativeResponseValue;
22367 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22369 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
22370 if(!isWasmInitialized) {
22371 throw new Error("initializeWasm() must be awaited first!");
22373 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
22374 // debug statements here
22376 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22378 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
22379 if(!isWasmInitialized) {
22380 throw new Error("initializeWasm() must be awaited first!");
22382 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
22383 return nativeResponseValue;
22385 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22387 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
22388 if(!isWasmInitialized) {
22389 throw new Error("initializeWasm() must be awaited first!");
22391 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
22392 // debug statements here
22394 // 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);
22396 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
22397 if(!isWasmInitialized) {
22398 throw new Error("initializeWasm() must be awaited first!");
22400 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
22401 return nativeResponseValue;
22403 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
22405 export function AnnouncementSignatures_clone_ptr(arg: number): number {
22406 if(!isWasmInitialized) {
22407 throw new Error("initializeWasm() must be awaited first!");
22409 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
22410 return nativeResponseValue;
22412 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
22414 export function AnnouncementSignatures_clone(orig: number): number {
22415 if(!isWasmInitialized) {
22416 throw new Error("initializeWasm() must be awaited first!");
22418 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
22419 return nativeResponseValue;
22421 // void NetAddress_free(struct LDKNetAddress this_ptr);
22423 export function NetAddress_free(this_ptr: number): void {
22424 if(!isWasmInitialized) {
22425 throw new Error("initializeWasm() must be awaited first!");
22427 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
22428 // debug statements here
22430 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
22432 export function NetAddress_clone_ptr(arg: number): number {
22433 if(!isWasmInitialized) {
22434 throw new Error("initializeWasm() must be awaited first!");
22436 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
22437 return nativeResponseValue;
22439 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
22441 export function NetAddress_clone(orig: number): number {
22442 if(!isWasmInitialized) {
22443 throw new Error("initializeWasm() must be awaited first!");
22445 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
22446 return nativeResponseValue;
22448 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
22450 export function NetAddress_ipv4(addr: number, port: number): number {
22451 if(!isWasmInitialized) {
22452 throw new Error("initializeWasm() must be awaited first!");
22454 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
22455 return nativeResponseValue;
22457 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
22459 export function NetAddress_ipv6(addr: number, port: number): number {
22460 if(!isWasmInitialized) {
22461 throw new Error("initializeWasm() must be awaited first!");
22463 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
22464 return nativeResponseValue;
22466 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
22468 export function NetAddress_onion_v2(a: number): number {
22469 if(!isWasmInitialized) {
22470 throw new Error("initializeWasm() must be awaited first!");
22472 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
22473 return nativeResponseValue;
22475 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
22477 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
22478 if(!isWasmInitialized) {
22479 throw new Error("initializeWasm() must be awaited first!");
22481 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
22482 return nativeResponseValue;
22484 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
22486 export function NetAddress_write(obj: number): number {
22487 if(!isWasmInitialized) {
22488 throw new Error("initializeWasm() must be awaited first!");
22490 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
22491 return nativeResponseValue;
22493 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
22495 export function NetAddress_read(ser: number): number {
22496 if(!isWasmInitialized) {
22497 throw new Error("initializeWasm() must be awaited first!");
22499 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
22500 return nativeResponseValue;
22502 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
22504 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
22505 if(!isWasmInitialized) {
22506 throw new Error("initializeWasm() must be awaited first!");
22508 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
22509 // debug statements here
22511 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22513 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
22514 if(!isWasmInitialized) {
22515 throw new Error("initializeWasm() must be awaited first!");
22517 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
22518 return nativeResponseValue;
22520 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
22522 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
22523 if(!isWasmInitialized) {
22524 throw new Error("initializeWasm() must be awaited first!");
22526 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
22527 // debug statements here
22529 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22531 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
22532 if(!isWasmInitialized) {
22533 throw new Error("initializeWasm() must be awaited first!");
22535 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
22536 return nativeResponseValue;
22538 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
22540 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
22541 if(!isWasmInitialized) {
22542 throw new Error("initializeWasm() must be awaited first!");
22544 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
22545 // debug statements here
22547 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22549 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
22550 if(!isWasmInitialized) {
22551 throw new Error("initializeWasm() must be awaited first!");
22553 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
22554 return nativeResponseValue;
22556 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22558 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
22559 if(!isWasmInitialized) {
22560 throw new Error("initializeWasm() must be awaited first!");
22562 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
22563 // debug statements here
22565 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
22567 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
22568 if(!isWasmInitialized) {
22569 throw new Error("initializeWasm() must be awaited first!");
22571 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
22572 return nativeResponseValue;
22574 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
22576 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
22577 if(!isWasmInitialized) {
22578 throw new Error("initializeWasm() must be awaited first!");
22580 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
22581 // debug statements here
22583 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
22585 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
22586 if(!isWasmInitialized) {
22587 throw new Error("initializeWasm() must be awaited first!");
22589 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
22590 return nativeResponseValue;
22592 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22594 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
22595 if(!isWasmInitialized) {
22596 throw new Error("initializeWasm() must be awaited first!");
22598 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
22599 // debug statements here
22601 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
22603 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
22604 if(!isWasmInitialized) {
22605 throw new Error("initializeWasm() must be awaited first!");
22607 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
22608 // debug statements here
22610 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
22612 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
22613 if(!isWasmInitialized) {
22614 throw new Error("initializeWasm() must be awaited first!");
22616 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
22617 return nativeResponseValue;
22619 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
22621 export function UnsignedNodeAnnouncement_clone(orig: number): number {
22622 if(!isWasmInitialized) {
22623 throw new Error("initializeWasm() must be awaited first!");
22625 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
22626 return nativeResponseValue;
22628 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
22630 export function NodeAnnouncement_free(this_obj: number): void {
22631 if(!isWasmInitialized) {
22632 throw new Error("initializeWasm() must be awaited first!");
22634 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
22635 // debug statements here
22637 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22639 export function NodeAnnouncement_get_signature(this_ptr: number): number {
22640 if(!isWasmInitialized) {
22641 throw new Error("initializeWasm() must be awaited first!");
22643 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
22644 return nativeResponseValue;
22646 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22648 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
22649 if(!isWasmInitialized) {
22650 throw new Error("initializeWasm() must be awaited first!");
22652 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
22653 // debug statements here
22655 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22657 export function NodeAnnouncement_get_contents(this_ptr: number): number {
22658 if(!isWasmInitialized) {
22659 throw new Error("initializeWasm() must be awaited first!");
22661 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
22662 return nativeResponseValue;
22664 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
22666 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
22667 if(!isWasmInitialized) {
22668 throw new Error("initializeWasm() must be awaited first!");
22670 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
22671 // debug statements here
22673 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
22675 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
22676 if(!isWasmInitialized) {
22677 throw new Error("initializeWasm() must be awaited first!");
22679 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
22680 return nativeResponseValue;
22682 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
22684 export function NodeAnnouncement_clone_ptr(arg: number): number {
22685 if(!isWasmInitialized) {
22686 throw new Error("initializeWasm() must be awaited first!");
22688 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
22689 return nativeResponseValue;
22691 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
22693 export function NodeAnnouncement_clone(orig: number): number {
22694 if(!isWasmInitialized) {
22695 throw new Error("initializeWasm() must be awaited first!");
22697 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
22698 return nativeResponseValue;
22700 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
22702 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
22703 if(!isWasmInitialized) {
22704 throw new Error("initializeWasm() must be awaited first!");
22706 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
22707 // debug statements here
22709 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22711 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
22712 if(!isWasmInitialized) {
22713 throw new Error("initializeWasm() must be awaited first!");
22715 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
22716 return nativeResponseValue;
22718 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
22720 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
22721 if(!isWasmInitialized) {
22722 throw new Error("initializeWasm() must be awaited first!");
22724 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
22725 // debug statements here
22727 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
22729 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
22730 if(!isWasmInitialized) {
22731 throw new Error("initializeWasm() must be awaited first!");
22733 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
22734 return nativeResponseValue;
22736 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22738 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
22739 if(!isWasmInitialized) {
22740 throw new Error("initializeWasm() must be awaited first!");
22742 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
22743 // debug statements here
22745 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22747 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
22748 if(!isWasmInitialized) {
22749 throw new Error("initializeWasm() must be awaited first!");
22751 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
22752 return nativeResponseValue;
22754 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
22756 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
22757 if(!isWasmInitialized) {
22758 throw new Error("initializeWasm() must be awaited first!");
22760 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
22761 // debug statements here
22763 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22765 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
22766 if(!isWasmInitialized) {
22767 throw new Error("initializeWasm() must be awaited first!");
22769 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
22770 return nativeResponseValue;
22772 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22774 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
22775 if(!isWasmInitialized) {
22776 throw new Error("initializeWasm() must be awaited first!");
22778 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
22779 // debug statements here
22781 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22783 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
22784 if(!isWasmInitialized) {
22785 throw new Error("initializeWasm() must be awaited first!");
22787 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
22788 return nativeResponseValue;
22790 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22792 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
22793 if(!isWasmInitialized) {
22794 throw new Error("initializeWasm() must be awaited first!");
22796 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
22797 // debug statements here
22799 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22801 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
22802 if(!isWasmInitialized) {
22803 throw new Error("initializeWasm() must be awaited first!");
22805 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
22806 return nativeResponseValue;
22808 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22810 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
22811 if(!isWasmInitialized) {
22812 throw new Error("initializeWasm() must be awaited first!");
22814 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
22815 // debug statements here
22817 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22819 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
22820 if(!isWasmInitialized) {
22821 throw new Error("initializeWasm() must be awaited first!");
22823 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
22824 return nativeResponseValue;
22826 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22828 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
22829 if(!isWasmInitialized) {
22830 throw new Error("initializeWasm() must be awaited first!");
22832 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
22833 // debug statements here
22835 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
22837 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
22838 if(!isWasmInitialized) {
22839 throw new Error("initializeWasm() must be awaited first!");
22841 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
22842 return nativeResponseValue;
22844 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
22846 export function UnsignedChannelAnnouncement_clone(orig: number): number {
22847 if(!isWasmInitialized) {
22848 throw new Error("initializeWasm() must be awaited first!");
22850 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
22851 return nativeResponseValue;
22853 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
22855 export function ChannelAnnouncement_free(this_obj: number): void {
22856 if(!isWasmInitialized) {
22857 throw new Error("initializeWasm() must be awaited first!");
22859 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
22860 // debug statements here
22862 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22864 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
22865 if(!isWasmInitialized) {
22866 throw new Error("initializeWasm() must be awaited first!");
22868 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
22869 return nativeResponseValue;
22871 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22873 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
22874 if(!isWasmInitialized) {
22875 throw new Error("initializeWasm() must be awaited first!");
22877 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
22878 // debug statements here
22880 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22882 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
22883 if(!isWasmInitialized) {
22884 throw new Error("initializeWasm() must be awaited first!");
22886 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
22887 return nativeResponseValue;
22889 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22891 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
22892 if(!isWasmInitialized) {
22893 throw new Error("initializeWasm() must be awaited first!");
22895 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
22896 // debug statements here
22898 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22900 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
22901 if(!isWasmInitialized) {
22902 throw new Error("initializeWasm() must be awaited first!");
22904 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
22905 return nativeResponseValue;
22907 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22909 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
22910 if(!isWasmInitialized) {
22911 throw new Error("initializeWasm() must be awaited first!");
22913 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
22914 // debug statements here
22916 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22918 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
22919 if(!isWasmInitialized) {
22920 throw new Error("initializeWasm() must be awaited first!");
22922 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
22923 return nativeResponseValue;
22925 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22927 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
22928 if(!isWasmInitialized) {
22929 throw new Error("initializeWasm() must be awaited first!");
22931 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
22932 // debug statements here
22934 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22936 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
22937 if(!isWasmInitialized) {
22938 throw new Error("initializeWasm() must be awaited first!");
22940 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
22941 return nativeResponseValue;
22943 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
22945 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
22946 if(!isWasmInitialized) {
22947 throw new Error("initializeWasm() must be awaited first!");
22949 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
22950 // debug statements here
22952 // 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);
22954 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 {
22955 if(!isWasmInitialized) {
22956 throw new Error("initializeWasm() must be awaited first!");
22958 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
22959 return nativeResponseValue;
22961 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
22963 export function ChannelAnnouncement_clone_ptr(arg: number): number {
22964 if(!isWasmInitialized) {
22965 throw new Error("initializeWasm() must be awaited first!");
22967 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
22968 return nativeResponseValue;
22970 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
22972 export function ChannelAnnouncement_clone(orig: number): number {
22973 if(!isWasmInitialized) {
22974 throw new Error("initializeWasm() must be awaited first!");
22976 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
22977 return nativeResponseValue;
22979 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
22981 export function UnsignedChannelUpdate_free(this_obj: number): void {
22982 if(!isWasmInitialized) {
22983 throw new Error("initializeWasm() must be awaited first!");
22985 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
22986 // debug statements here
22988 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
22990 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
22991 if(!isWasmInitialized) {
22992 throw new Error("initializeWasm() must be awaited first!");
22994 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
22995 return nativeResponseValue;
22997 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22999 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
23000 if(!isWasmInitialized) {
23001 throw new Error("initializeWasm() must be awaited first!");
23003 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23004 // debug statements here
23006 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23008 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
23009 if(!isWasmInitialized) {
23010 throw new Error("initializeWasm() must be awaited first!");
23012 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23013 return nativeResponseValue;
23015 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23017 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
23018 if(!isWasmInitialized) {
23019 throw new Error("initializeWasm() must be awaited first!");
23021 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23022 // debug statements here
23024 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23026 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
23027 if(!isWasmInitialized) {
23028 throw new Error("initializeWasm() must be awaited first!");
23030 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23031 return nativeResponseValue;
23033 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23035 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
23036 if(!isWasmInitialized) {
23037 throw new Error("initializeWasm() must be awaited first!");
23039 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23040 // debug statements here
23042 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23044 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
23045 if(!isWasmInitialized) {
23046 throw new Error("initializeWasm() must be awaited first!");
23048 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23049 return nativeResponseValue;
23051 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23053 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
23054 if(!isWasmInitialized) {
23055 throw new Error("initializeWasm() must be awaited first!");
23057 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23058 // debug statements here
23060 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23062 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
23063 if(!isWasmInitialized) {
23064 throw new Error("initializeWasm() must be awaited first!");
23066 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23067 return nativeResponseValue;
23069 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23071 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23072 if(!isWasmInitialized) {
23073 throw new Error("initializeWasm() must be awaited first!");
23075 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23076 // debug statements here
23078 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23080 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
23081 if(!isWasmInitialized) {
23082 throw new Error("initializeWasm() must be awaited first!");
23084 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23085 return nativeResponseValue;
23087 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23089 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23090 if(!isWasmInitialized) {
23091 throw new Error("initializeWasm() must be awaited first!");
23093 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23094 // debug statements here
23096 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23098 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
23099 if(!isWasmInitialized) {
23100 throw new Error("initializeWasm() must be awaited first!");
23102 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23103 return nativeResponseValue;
23105 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23107 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
23108 if(!isWasmInitialized) {
23109 throw new Error("initializeWasm() must be awaited first!");
23111 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23112 // debug statements here
23114 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23116 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
23117 if(!isWasmInitialized) {
23118 throw new Error("initializeWasm() must be awaited first!");
23120 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23121 return nativeResponseValue;
23123 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23125 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
23126 if(!isWasmInitialized) {
23127 throw new Error("initializeWasm() must be awaited first!");
23129 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23130 // debug statements here
23132 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23134 export function UnsignedChannelUpdate_set_excess_data(this_ptr: number, val: number): void {
23135 if(!isWasmInitialized) {
23136 throw new Error("initializeWasm() must be awaited first!");
23138 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23139 // debug statements here
23141 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23143 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
23144 if(!isWasmInitialized) {
23145 throw new Error("initializeWasm() must be awaited first!");
23147 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23148 return nativeResponseValue;
23150 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
23152 export function UnsignedChannelUpdate_clone(orig: number): number {
23153 if(!isWasmInitialized) {
23154 throw new Error("initializeWasm() must be awaited first!");
23156 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
23157 return nativeResponseValue;
23159 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
23161 export function ChannelUpdate_free(this_obj: number): void {
23162 if(!isWasmInitialized) {
23163 throw new Error("initializeWasm() must be awaited first!");
23165 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
23166 // debug statements here
23168 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23170 export function ChannelUpdate_get_signature(this_ptr: number): number {
23171 if(!isWasmInitialized) {
23172 throw new Error("initializeWasm() must be awaited first!");
23174 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
23175 return nativeResponseValue;
23177 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
23179 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
23180 if(!isWasmInitialized) {
23181 throw new Error("initializeWasm() must be awaited first!");
23183 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
23184 // debug statements here
23186 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23188 export function ChannelUpdate_get_contents(this_ptr: number): number {
23189 if(!isWasmInitialized) {
23190 throw new Error("initializeWasm() must be awaited first!");
23192 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
23193 return nativeResponseValue;
23195 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
23197 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
23198 if(!isWasmInitialized) {
23199 throw new Error("initializeWasm() must be awaited first!");
23201 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
23202 // debug statements here
23204 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
23206 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
23207 if(!isWasmInitialized) {
23208 throw new Error("initializeWasm() must be awaited first!");
23210 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
23211 return nativeResponseValue;
23213 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
23215 export function ChannelUpdate_clone_ptr(arg: number): number {
23216 if(!isWasmInitialized) {
23217 throw new Error("initializeWasm() must be awaited first!");
23219 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
23220 return nativeResponseValue;
23222 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
23224 export function ChannelUpdate_clone(orig: number): number {
23225 if(!isWasmInitialized) {
23226 throw new Error("initializeWasm() must be awaited first!");
23228 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
23229 return nativeResponseValue;
23231 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
23233 export function QueryChannelRange_free(this_obj: number): void {
23234 if(!isWasmInitialized) {
23235 throw new Error("initializeWasm() must be awaited first!");
23237 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
23238 // debug statements here
23240 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
23242 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
23243 if(!isWasmInitialized) {
23244 throw new Error("initializeWasm() must be awaited first!");
23246 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
23247 return nativeResponseValue;
23249 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23251 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23252 if(!isWasmInitialized) {
23253 throw new Error("initializeWasm() must be awaited first!");
23255 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
23256 // debug statements here
23258 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23260 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
23261 if(!isWasmInitialized) {
23262 throw new Error("initializeWasm() must be awaited first!");
23264 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
23265 return nativeResponseValue;
23267 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23269 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23270 if(!isWasmInitialized) {
23271 throw new Error("initializeWasm() must be awaited first!");
23273 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
23274 // debug statements here
23276 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23278 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
23279 if(!isWasmInitialized) {
23280 throw new Error("initializeWasm() must be awaited first!");
23282 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
23283 return nativeResponseValue;
23285 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23287 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23288 if(!isWasmInitialized) {
23289 throw new Error("initializeWasm() must be awaited first!");
23291 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
23292 // debug statements here
23294 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
23296 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
23297 if(!isWasmInitialized) {
23298 throw new Error("initializeWasm() must be awaited first!");
23300 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
23301 return nativeResponseValue;
23303 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
23305 export function QueryChannelRange_clone_ptr(arg: number): number {
23306 if(!isWasmInitialized) {
23307 throw new Error("initializeWasm() must be awaited first!");
23309 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
23310 return nativeResponseValue;
23312 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
23314 export function QueryChannelRange_clone(orig: number): number {
23315 if(!isWasmInitialized) {
23316 throw new Error("initializeWasm() must be awaited first!");
23318 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
23319 return nativeResponseValue;
23321 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
23323 export function ReplyChannelRange_free(this_obj: number): void {
23324 if(!isWasmInitialized) {
23325 throw new Error("initializeWasm() must be awaited first!");
23327 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
23328 // debug statements here
23330 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
23332 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
23333 if(!isWasmInitialized) {
23334 throw new Error("initializeWasm() must be awaited first!");
23336 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
23337 return nativeResponseValue;
23339 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23341 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23342 if(!isWasmInitialized) {
23343 throw new Error("initializeWasm() must be awaited first!");
23345 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
23346 // debug statements here
23348 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23350 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
23351 if(!isWasmInitialized) {
23352 throw new Error("initializeWasm() must be awaited first!");
23354 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
23355 return nativeResponseValue;
23357 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23359 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23360 if(!isWasmInitialized) {
23361 throw new Error("initializeWasm() must be awaited first!");
23363 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
23364 // debug statements here
23366 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23368 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
23369 if(!isWasmInitialized) {
23370 throw new Error("initializeWasm() must be awaited first!");
23372 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
23373 return nativeResponseValue;
23375 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23377 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23378 if(!isWasmInitialized) {
23379 throw new Error("initializeWasm() must be awaited first!");
23381 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
23382 // debug statements here
23384 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23386 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
23387 if(!isWasmInitialized) {
23388 throw new Error("initializeWasm() must be awaited first!");
23390 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
23391 return nativeResponseValue;
23393 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
23395 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
23396 if(!isWasmInitialized) {
23397 throw new Error("initializeWasm() must be awaited first!");
23399 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
23400 // debug statements here
23402 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23404 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
23405 if(!isWasmInitialized) {
23406 throw new Error("initializeWasm() must be awaited first!");
23408 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
23409 // debug statements here
23411 // 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);
23413 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 {
23414 if(!isWasmInitialized) {
23415 throw new Error("initializeWasm() must be awaited first!");
23417 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
23418 return nativeResponseValue;
23420 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
23422 export function ReplyChannelRange_clone_ptr(arg: number): number {
23423 if(!isWasmInitialized) {
23424 throw new Error("initializeWasm() must be awaited first!");
23426 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
23427 return nativeResponseValue;
23429 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
23431 export function ReplyChannelRange_clone(orig: number): number {
23432 if(!isWasmInitialized) {
23433 throw new Error("initializeWasm() must be awaited first!");
23435 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
23436 return nativeResponseValue;
23438 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
23440 export function QueryShortChannelIds_free(this_obj: number): void {
23441 if(!isWasmInitialized) {
23442 throw new Error("initializeWasm() must be awaited first!");
23444 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
23445 // debug statements here
23447 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
23449 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
23450 if(!isWasmInitialized) {
23451 throw new Error("initializeWasm() must be awaited first!");
23453 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
23454 return nativeResponseValue;
23456 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23458 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
23459 if(!isWasmInitialized) {
23460 throw new Error("initializeWasm() must be awaited first!");
23462 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
23463 // debug statements here
23465 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23467 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
23468 if(!isWasmInitialized) {
23469 throw new Error("initializeWasm() must be awaited first!");
23471 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
23472 // debug statements here
23474 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
23476 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
23477 if(!isWasmInitialized) {
23478 throw new Error("initializeWasm() must be awaited first!");
23480 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
23481 return nativeResponseValue;
23483 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
23485 export function QueryShortChannelIds_clone_ptr(arg: number): number {
23486 if(!isWasmInitialized) {
23487 throw new Error("initializeWasm() must be awaited first!");
23489 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
23490 return nativeResponseValue;
23492 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
23494 export function QueryShortChannelIds_clone(orig: number): number {
23495 if(!isWasmInitialized) {
23496 throw new Error("initializeWasm() must be awaited first!");
23498 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
23499 return nativeResponseValue;
23501 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
23503 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
23504 if(!isWasmInitialized) {
23505 throw new Error("initializeWasm() must be awaited first!");
23507 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
23508 // debug statements here
23510 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
23512 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
23513 if(!isWasmInitialized) {
23514 throw new Error("initializeWasm() must be awaited first!");
23516 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
23517 return nativeResponseValue;
23519 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23521 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
23522 if(!isWasmInitialized) {
23523 throw new Error("initializeWasm() must be awaited first!");
23525 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
23526 // debug statements here
23528 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
23530 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
23531 if(!isWasmInitialized) {
23532 throw new Error("initializeWasm() must be awaited first!");
23534 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
23535 return nativeResponseValue;
23537 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
23539 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
23540 if(!isWasmInitialized) {
23541 throw new Error("initializeWasm() must be awaited first!");
23543 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
23544 // debug statements here
23546 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
23548 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
23549 if(!isWasmInitialized) {
23550 throw new Error("initializeWasm() must be awaited first!");
23552 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
23553 return nativeResponseValue;
23555 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
23557 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
23558 if(!isWasmInitialized) {
23559 throw new Error("initializeWasm() must be awaited first!");
23561 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
23562 return nativeResponseValue;
23564 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
23566 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
23567 if(!isWasmInitialized) {
23568 throw new Error("initializeWasm() must be awaited first!");
23570 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
23571 return nativeResponseValue;
23573 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
23575 export function GossipTimestampFilter_free(this_obj: number): void {
23576 if(!isWasmInitialized) {
23577 throw new Error("initializeWasm() must be awaited first!");
23579 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
23580 // debug statements here
23582 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
23584 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
23585 if(!isWasmInitialized) {
23586 throw new Error("initializeWasm() must be awaited first!");
23588 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
23589 return nativeResponseValue;
23591 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23593 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
23594 if(!isWasmInitialized) {
23595 throw new Error("initializeWasm() must be awaited first!");
23597 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
23598 // debug statements here
23600 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23602 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
23603 if(!isWasmInitialized) {
23604 throw new Error("initializeWasm() must be awaited first!");
23606 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
23607 return nativeResponseValue;
23609 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23611 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
23612 if(!isWasmInitialized) {
23613 throw new Error("initializeWasm() must be awaited first!");
23615 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
23616 // debug statements here
23618 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23620 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
23621 if(!isWasmInitialized) {
23622 throw new Error("initializeWasm() must be awaited first!");
23624 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
23625 return nativeResponseValue;
23627 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23629 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
23630 if(!isWasmInitialized) {
23631 throw new Error("initializeWasm() must be awaited first!");
23633 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
23634 // debug statements here
23636 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
23638 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
23639 if(!isWasmInitialized) {
23640 throw new Error("initializeWasm() must be awaited first!");
23642 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
23643 return nativeResponseValue;
23645 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
23647 export function GossipTimestampFilter_clone_ptr(arg: number): number {
23648 if(!isWasmInitialized) {
23649 throw new Error("initializeWasm() must be awaited first!");
23651 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
23652 return nativeResponseValue;
23654 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
23656 export function GossipTimestampFilter_clone(orig: number): number {
23657 if(!isWasmInitialized) {
23658 throw new Error("initializeWasm() must be awaited first!");
23660 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
23661 return nativeResponseValue;
23663 // void ErrorAction_free(struct LDKErrorAction this_ptr);
23665 export function ErrorAction_free(this_ptr: number): void {
23666 if(!isWasmInitialized) {
23667 throw new Error("initializeWasm() must be awaited first!");
23669 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
23670 // debug statements here
23672 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
23674 export function ErrorAction_clone_ptr(arg: number): number {
23675 if(!isWasmInitialized) {
23676 throw new Error("initializeWasm() must be awaited first!");
23678 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
23679 return nativeResponseValue;
23681 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
23683 export function ErrorAction_clone(orig: number): number {
23684 if(!isWasmInitialized) {
23685 throw new Error("initializeWasm() must be awaited first!");
23687 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
23688 return nativeResponseValue;
23690 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
23692 export function ErrorAction_disconnect_peer(msg: number): number {
23693 if(!isWasmInitialized) {
23694 throw new Error("initializeWasm() must be awaited first!");
23696 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
23697 return nativeResponseValue;
23699 // struct LDKErrorAction ErrorAction_ignore_error(void);
23701 export function ErrorAction_ignore_error(): number {
23702 if(!isWasmInitialized) {
23703 throw new Error("initializeWasm() must be awaited first!");
23705 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
23706 return nativeResponseValue;
23708 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
23710 export function ErrorAction_ignore_and_log(a: Level): number {
23711 if(!isWasmInitialized) {
23712 throw new Error("initializeWasm() must be awaited first!");
23714 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
23715 return nativeResponseValue;
23717 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
23719 export function ErrorAction_ignore_duplicate_gossip(): number {
23720 if(!isWasmInitialized) {
23721 throw new Error("initializeWasm() must be awaited first!");
23723 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
23724 return nativeResponseValue;
23726 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
23728 export function ErrorAction_send_error_message(msg: number): number {
23729 if(!isWasmInitialized) {
23730 throw new Error("initializeWasm() must be awaited first!");
23732 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
23733 return nativeResponseValue;
23735 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
23737 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
23738 if(!isWasmInitialized) {
23739 throw new Error("initializeWasm() must be awaited first!");
23741 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
23742 return nativeResponseValue;
23744 // void LightningError_free(struct LDKLightningError this_obj);
23746 export function LightningError_free(this_obj: number): void {
23747 if(!isWasmInitialized) {
23748 throw new Error("initializeWasm() must be awaited first!");
23750 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
23751 // debug statements here
23753 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
23755 export function LightningError_get_err(this_ptr: number): number {
23756 if(!isWasmInitialized) {
23757 throw new Error("initializeWasm() must be awaited first!");
23759 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
23760 return nativeResponseValue;
23762 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
23764 export function LightningError_set_err(this_ptr: number, val: number): void {
23765 if(!isWasmInitialized) {
23766 throw new Error("initializeWasm() must be awaited first!");
23768 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
23769 // debug statements here
23771 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
23773 export function LightningError_get_action(this_ptr: number): number {
23774 if(!isWasmInitialized) {
23775 throw new Error("initializeWasm() must be awaited first!");
23777 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
23778 return nativeResponseValue;
23780 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
23782 export function LightningError_set_action(this_ptr: number, val: number): void {
23783 if(!isWasmInitialized) {
23784 throw new Error("initializeWasm() must be awaited first!");
23786 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
23787 // debug statements here
23789 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
23791 export function LightningError_new(err_arg: number, action_arg: number): number {
23792 if(!isWasmInitialized) {
23793 throw new Error("initializeWasm() must be awaited first!");
23795 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
23796 return nativeResponseValue;
23798 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
23800 export function LightningError_clone_ptr(arg: number): number {
23801 if(!isWasmInitialized) {
23802 throw new Error("initializeWasm() must be awaited first!");
23804 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
23805 return nativeResponseValue;
23807 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
23809 export function LightningError_clone(orig: number): number {
23810 if(!isWasmInitialized) {
23811 throw new Error("initializeWasm() must be awaited first!");
23813 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
23814 return nativeResponseValue;
23816 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
23818 export function CommitmentUpdate_free(this_obj: number): void {
23819 if(!isWasmInitialized) {
23820 throw new Error("initializeWasm() must be awaited first!");
23822 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
23823 // debug statements here
23825 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23827 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
23828 if(!isWasmInitialized) {
23829 throw new Error("initializeWasm() must be awaited first!");
23831 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
23832 return nativeResponseValue;
23834 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
23836 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
23837 if(!isWasmInitialized) {
23838 throw new Error("initializeWasm() must be awaited first!");
23840 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
23841 // debug statements here
23843 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23845 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
23846 if(!isWasmInitialized) {
23847 throw new Error("initializeWasm() must be awaited first!");
23849 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
23850 return nativeResponseValue;
23852 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
23854 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
23855 if(!isWasmInitialized) {
23856 throw new Error("initializeWasm() must be awaited first!");
23858 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
23859 // debug statements here
23861 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23863 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
23864 if(!isWasmInitialized) {
23865 throw new Error("initializeWasm() must be awaited first!");
23867 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
23868 return nativeResponseValue;
23870 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
23872 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
23873 if(!isWasmInitialized) {
23874 throw new Error("initializeWasm() must be awaited first!");
23876 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
23877 // debug statements here
23879 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23881 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
23882 if(!isWasmInitialized) {
23883 throw new Error("initializeWasm() must be awaited first!");
23885 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
23886 return nativeResponseValue;
23888 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
23890 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
23891 if(!isWasmInitialized) {
23892 throw new Error("initializeWasm() must be awaited first!");
23894 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
23895 // debug statements here
23897 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23899 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
23900 if(!isWasmInitialized) {
23901 throw new Error("initializeWasm() must be awaited first!");
23903 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
23904 return nativeResponseValue;
23906 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
23908 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
23909 if(!isWasmInitialized) {
23910 throw new Error("initializeWasm() must be awaited first!");
23912 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
23913 // debug statements here
23915 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23917 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
23918 if(!isWasmInitialized) {
23919 throw new Error("initializeWasm() must be awaited first!");
23921 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
23922 return nativeResponseValue;
23924 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
23926 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
23927 if(!isWasmInitialized) {
23928 throw new Error("initializeWasm() must be awaited first!");
23930 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
23931 // debug statements here
23933 // 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);
23935 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 {
23936 if(!isWasmInitialized) {
23937 throw new Error("initializeWasm() must be awaited first!");
23939 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);
23940 return nativeResponseValue;
23942 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
23944 export function CommitmentUpdate_clone_ptr(arg: number): number {
23945 if(!isWasmInitialized) {
23946 throw new Error("initializeWasm() must be awaited first!");
23948 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
23949 return nativeResponseValue;
23951 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
23953 export function CommitmentUpdate_clone(orig: number): number {
23954 if(!isWasmInitialized) {
23955 throw new Error("initializeWasm() must be awaited first!");
23957 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
23958 return nativeResponseValue;
23960 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
23962 export function ChannelMessageHandler_free(this_ptr: number): void {
23963 if(!isWasmInitialized) {
23964 throw new Error("initializeWasm() must be awaited first!");
23966 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
23967 // debug statements here
23969 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
23971 export function RoutingMessageHandler_free(this_ptr: number): void {
23972 if(!isWasmInitialized) {
23973 throw new Error("initializeWasm() must be awaited first!");
23975 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
23976 // debug statements here
23978 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
23980 export function AcceptChannel_write(obj: number): number {
23981 if(!isWasmInitialized) {
23982 throw new Error("initializeWasm() must be awaited first!");
23984 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
23985 return nativeResponseValue;
23987 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
23989 export function AcceptChannel_read(ser: number): number {
23990 if(!isWasmInitialized) {
23991 throw new Error("initializeWasm() must be awaited first!");
23993 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
23994 return nativeResponseValue;
23996 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
23998 export function AnnouncementSignatures_write(obj: number): number {
23999 if(!isWasmInitialized) {
24000 throw new Error("initializeWasm() must be awaited first!");
24002 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24003 return nativeResponseValue;
24005 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24007 export function AnnouncementSignatures_read(ser: number): number {
24008 if(!isWasmInitialized) {
24009 throw new Error("initializeWasm() must be awaited first!");
24011 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24012 return nativeResponseValue;
24014 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24016 export function ChannelReestablish_write(obj: number): number {
24017 if(!isWasmInitialized) {
24018 throw new Error("initializeWasm() must be awaited first!");
24020 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24021 return nativeResponseValue;
24023 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24025 export function ChannelReestablish_read(ser: number): number {
24026 if(!isWasmInitialized) {
24027 throw new Error("initializeWasm() must be awaited first!");
24029 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24030 return nativeResponseValue;
24032 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24034 export function ClosingSigned_write(obj: number): number {
24035 if(!isWasmInitialized) {
24036 throw new Error("initializeWasm() must be awaited first!");
24038 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24039 return nativeResponseValue;
24041 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24043 export function ClosingSigned_read(ser: number): number {
24044 if(!isWasmInitialized) {
24045 throw new Error("initializeWasm() must be awaited first!");
24047 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24048 return nativeResponseValue;
24050 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24052 export function ClosingSignedFeeRange_write(obj: number): number {
24053 if(!isWasmInitialized) {
24054 throw new Error("initializeWasm() must be awaited first!");
24056 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24057 return nativeResponseValue;
24059 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24061 export function ClosingSignedFeeRange_read(ser: number): number {
24062 if(!isWasmInitialized) {
24063 throw new Error("initializeWasm() must be awaited first!");
24065 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24066 return nativeResponseValue;
24068 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24070 export function CommitmentSigned_write(obj: number): number {
24071 if(!isWasmInitialized) {
24072 throw new Error("initializeWasm() must be awaited first!");
24074 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24075 return nativeResponseValue;
24077 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24079 export function CommitmentSigned_read(ser: number): number {
24080 if(!isWasmInitialized) {
24081 throw new Error("initializeWasm() must be awaited first!");
24083 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24084 return nativeResponseValue;
24086 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24088 export function FundingCreated_write(obj: number): number {
24089 if(!isWasmInitialized) {
24090 throw new Error("initializeWasm() must be awaited first!");
24092 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24093 return nativeResponseValue;
24095 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24097 export function FundingCreated_read(ser: number): number {
24098 if(!isWasmInitialized) {
24099 throw new Error("initializeWasm() must be awaited first!");
24101 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24102 return nativeResponseValue;
24104 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24106 export function FundingSigned_write(obj: number): number {
24107 if(!isWasmInitialized) {
24108 throw new Error("initializeWasm() must be awaited first!");
24110 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24111 return nativeResponseValue;
24113 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24115 export function FundingSigned_read(ser: number): number {
24116 if(!isWasmInitialized) {
24117 throw new Error("initializeWasm() must be awaited first!");
24119 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24120 return nativeResponseValue;
24122 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24124 export function ChannelReady_write(obj: number): number {
24125 if(!isWasmInitialized) {
24126 throw new Error("initializeWasm() must be awaited first!");
24128 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24129 return nativeResponseValue;
24131 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
24133 export function ChannelReady_read(ser: number): number {
24134 if(!isWasmInitialized) {
24135 throw new Error("initializeWasm() must be awaited first!");
24137 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
24138 return nativeResponseValue;
24140 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
24142 export function Init_write(obj: number): number {
24143 if(!isWasmInitialized) {
24144 throw new Error("initializeWasm() must be awaited first!");
24146 const nativeResponseValue = wasm.TS_Init_write(obj);
24147 return nativeResponseValue;
24149 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
24151 export function Init_read(ser: number): number {
24152 if(!isWasmInitialized) {
24153 throw new Error("initializeWasm() must be awaited first!");
24155 const nativeResponseValue = wasm.TS_Init_read(ser);
24156 return nativeResponseValue;
24158 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
24160 export function OpenChannel_write(obj: number): number {
24161 if(!isWasmInitialized) {
24162 throw new Error("initializeWasm() must be awaited first!");
24164 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
24165 return nativeResponseValue;
24167 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
24169 export function OpenChannel_read(ser: number): number {
24170 if(!isWasmInitialized) {
24171 throw new Error("initializeWasm() must be awaited first!");
24173 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
24174 return nativeResponseValue;
24176 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
24178 export function RevokeAndACK_write(obj: number): number {
24179 if(!isWasmInitialized) {
24180 throw new Error("initializeWasm() must be awaited first!");
24182 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
24183 return nativeResponseValue;
24185 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
24187 export function RevokeAndACK_read(ser: number): number {
24188 if(!isWasmInitialized) {
24189 throw new Error("initializeWasm() must be awaited first!");
24191 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
24192 return nativeResponseValue;
24194 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
24196 export function Shutdown_write(obj: number): number {
24197 if(!isWasmInitialized) {
24198 throw new Error("initializeWasm() must be awaited first!");
24200 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
24201 return nativeResponseValue;
24203 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
24205 export function Shutdown_read(ser: number): number {
24206 if(!isWasmInitialized) {
24207 throw new Error("initializeWasm() must be awaited first!");
24209 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
24210 return nativeResponseValue;
24212 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
24214 export function UpdateFailHTLC_write(obj: number): number {
24215 if(!isWasmInitialized) {
24216 throw new Error("initializeWasm() must be awaited first!");
24218 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
24219 return nativeResponseValue;
24221 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
24223 export function UpdateFailHTLC_read(ser: number): number {
24224 if(!isWasmInitialized) {
24225 throw new Error("initializeWasm() must be awaited first!");
24227 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
24228 return nativeResponseValue;
24230 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
24232 export function UpdateFailMalformedHTLC_write(obj: number): number {
24233 if(!isWasmInitialized) {
24234 throw new Error("initializeWasm() must be awaited first!");
24236 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
24237 return nativeResponseValue;
24239 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
24241 export function UpdateFailMalformedHTLC_read(ser: number): number {
24242 if(!isWasmInitialized) {
24243 throw new Error("initializeWasm() must be awaited first!");
24245 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
24246 return nativeResponseValue;
24248 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
24250 export function UpdateFee_write(obj: number): number {
24251 if(!isWasmInitialized) {
24252 throw new Error("initializeWasm() must be awaited first!");
24254 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
24255 return nativeResponseValue;
24257 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
24259 export function UpdateFee_read(ser: number): number {
24260 if(!isWasmInitialized) {
24261 throw new Error("initializeWasm() must be awaited first!");
24263 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
24264 return nativeResponseValue;
24266 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
24268 export function UpdateFulfillHTLC_write(obj: number): number {
24269 if(!isWasmInitialized) {
24270 throw new Error("initializeWasm() must be awaited first!");
24272 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
24273 return nativeResponseValue;
24275 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
24277 export function UpdateFulfillHTLC_read(ser: number): number {
24278 if(!isWasmInitialized) {
24279 throw new Error("initializeWasm() must be awaited first!");
24281 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
24282 return nativeResponseValue;
24284 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
24286 export function UpdateAddHTLC_write(obj: number): number {
24287 if(!isWasmInitialized) {
24288 throw new Error("initializeWasm() must be awaited first!");
24290 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
24291 return nativeResponseValue;
24293 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
24295 export function UpdateAddHTLC_read(ser: number): number {
24296 if(!isWasmInitialized) {
24297 throw new Error("initializeWasm() must be awaited first!");
24299 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
24300 return nativeResponseValue;
24302 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
24304 export function Ping_write(obj: number): number {
24305 if(!isWasmInitialized) {
24306 throw new Error("initializeWasm() must be awaited first!");
24308 const nativeResponseValue = wasm.TS_Ping_write(obj);
24309 return nativeResponseValue;
24311 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
24313 export function Ping_read(ser: number): number {
24314 if(!isWasmInitialized) {
24315 throw new Error("initializeWasm() must be awaited first!");
24317 const nativeResponseValue = wasm.TS_Ping_read(ser);
24318 return nativeResponseValue;
24320 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
24322 export function Pong_write(obj: number): number {
24323 if(!isWasmInitialized) {
24324 throw new Error("initializeWasm() must be awaited first!");
24326 const nativeResponseValue = wasm.TS_Pong_write(obj);
24327 return nativeResponseValue;
24329 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
24331 export function Pong_read(ser: number): number {
24332 if(!isWasmInitialized) {
24333 throw new Error("initializeWasm() must be awaited first!");
24335 const nativeResponseValue = wasm.TS_Pong_read(ser);
24336 return nativeResponseValue;
24338 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
24340 export function UnsignedChannelAnnouncement_write(obj: number): number {
24341 if(!isWasmInitialized) {
24342 throw new Error("initializeWasm() must be awaited first!");
24344 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
24345 return nativeResponseValue;
24347 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
24349 export function UnsignedChannelAnnouncement_read(ser: number): number {
24350 if(!isWasmInitialized) {
24351 throw new Error("initializeWasm() must be awaited first!");
24353 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
24354 return nativeResponseValue;
24356 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
24358 export function ChannelAnnouncement_write(obj: number): number {
24359 if(!isWasmInitialized) {
24360 throw new Error("initializeWasm() must be awaited first!");
24362 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
24363 return nativeResponseValue;
24365 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
24367 export function ChannelAnnouncement_read(ser: number): number {
24368 if(!isWasmInitialized) {
24369 throw new Error("initializeWasm() must be awaited first!");
24371 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
24372 return nativeResponseValue;
24374 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
24376 export function UnsignedChannelUpdate_write(obj: number): number {
24377 if(!isWasmInitialized) {
24378 throw new Error("initializeWasm() must be awaited first!");
24380 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
24381 return nativeResponseValue;
24383 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
24385 export function UnsignedChannelUpdate_read(ser: number): number {
24386 if(!isWasmInitialized) {
24387 throw new Error("initializeWasm() must be awaited first!");
24389 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
24390 return nativeResponseValue;
24392 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
24394 export function ChannelUpdate_write(obj: number): number {
24395 if(!isWasmInitialized) {
24396 throw new Error("initializeWasm() must be awaited first!");
24398 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
24399 return nativeResponseValue;
24401 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
24403 export function ChannelUpdate_read(ser: number): number {
24404 if(!isWasmInitialized) {
24405 throw new Error("initializeWasm() must be awaited first!");
24407 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
24408 return nativeResponseValue;
24410 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
24412 export function ErrorMessage_write(obj: number): number {
24413 if(!isWasmInitialized) {
24414 throw new Error("initializeWasm() must be awaited first!");
24416 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
24417 return nativeResponseValue;
24419 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
24421 export function ErrorMessage_read(ser: number): number {
24422 if(!isWasmInitialized) {
24423 throw new Error("initializeWasm() must be awaited first!");
24425 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
24426 return nativeResponseValue;
24428 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
24430 export function WarningMessage_write(obj: number): number {
24431 if(!isWasmInitialized) {
24432 throw new Error("initializeWasm() must be awaited first!");
24434 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
24435 return nativeResponseValue;
24437 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
24439 export function WarningMessage_read(ser: number): number {
24440 if(!isWasmInitialized) {
24441 throw new Error("initializeWasm() must be awaited first!");
24443 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
24444 return nativeResponseValue;
24446 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
24448 export function UnsignedNodeAnnouncement_write(obj: number): number {
24449 if(!isWasmInitialized) {
24450 throw new Error("initializeWasm() must be awaited first!");
24452 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
24453 return nativeResponseValue;
24455 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
24457 export function UnsignedNodeAnnouncement_read(ser: number): number {
24458 if(!isWasmInitialized) {
24459 throw new Error("initializeWasm() must be awaited first!");
24461 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
24462 return nativeResponseValue;
24464 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
24466 export function NodeAnnouncement_write(obj: number): number {
24467 if(!isWasmInitialized) {
24468 throw new Error("initializeWasm() must be awaited first!");
24470 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
24471 return nativeResponseValue;
24473 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
24475 export function NodeAnnouncement_read(ser: number): number {
24476 if(!isWasmInitialized) {
24477 throw new Error("initializeWasm() must be awaited first!");
24479 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
24480 return nativeResponseValue;
24482 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
24484 export function QueryShortChannelIds_read(ser: number): number {
24485 if(!isWasmInitialized) {
24486 throw new Error("initializeWasm() must be awaited first!");
24488 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
24489 return nativeResponseValue;
24491 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
24493 export function QueryShortChannelIds_write(obj: number): number {
24494 if(!isWasmInitialized) {
24495 throw new Error("initializeWasm() must be awaited first!");
24497 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
24498 return nativeResponseValue;
24500 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
24502 export function ReplyShortChannelIdsEnd_write(obj: number): number {
24503 if(!isWasmInitialized) {
24504 throw new Error("initializeWasm() must be awaited first!");
24506 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
24507 return nativeResponseValue;
24509 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
24511 export function ReplyShortChannelIdsEnd_read(ser: number): number {
24512 if(!isWasmInitialized) {
24513 throw new Error("initializeWasm() must be awaited first!");
24515 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
24516 return nativeResponseValue;
24518 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
24520 export function QueryChannelRange_end_blocknum(this_arg: number): number {
24521 if(!isWasmInitialized) {
24522 throw new Error("initializeWasm() must be awaited first!");
24524 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
24525 return nativeResponseValue;
24527 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
24529 export function QueryChannelRange_write(obj: number): number {
24530 if(!isWasmInitialized) {
24531 throw new Error("initializeWasm() must be awaited first!");
24533 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
24534 return nativeResponseValue;
24536 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
24538 export function QueryChannelRange_read(ser: number): number {
24539 if(!isWasmInitialized) {
24540 throw new Error("initializeWasm() must be awaited first!");
24542 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
24543 return nativeResponseValue;
24545 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
24547 export function ReplyChannelRange_read(ser: number): number {
24548 if(!isWasmInitialized) {
24549 throw new Error("initializeWasm() must be awaited first!");
24551 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
24552 return nativeResponseValue;
24554 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
24556 export function ReplyChannelRange_write(obj: number): number {
24557 if(!isWasmInitialized) {
24558 throw new Error("initializeWasm() must be awaited first!");
24560 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
24561 return nativeResponseValue;
24563 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
24565 export function GossipTimestampFilter_write(obj: number): number {
24566 if(!isWasmInitialized) {
24567 throw new Error("initializeWasm() must be awaited first!");
24569 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
24570 return nativeResponseValue;
24572 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
24574 export function GossipTimestampFilter_read(ser: number): number {
24575 if(!isWasmInitialized) {
24576 throw new Error("initializeWasm() must be awaited first!");
24578 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
24579 return nativeResponseValue;
24581 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
24583 export function CustomMessageHandler_free(this_ptr: number): void {
24584 if(!isWasmInitialized) {
24585 throw new Error("initializeWasm() must be awaited first!");
24587 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
24588 // debug statements here
24590 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
24592 export function IgnoringMessageHandler_free(this_obj: number): void {
24593 if(!isWasmInitialized) {
24594 throw new Error("initializeWasm() must be awaited first!");
24596 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
24597 // debug statements here
24599 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
24601 export function IgnoringMessageHandler_new(): number {
24602 if(!isWasmInitialized) {
24603 throw new Error("initializeWasm() must be awaited first!");
24605 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
24606 return nativeResponseValue;
24608 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24610 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24611 if(!isWasmInitialized) {
24612 throw new Error("initializeWasm() must be awaited first!");
24614 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
24615 return nativeResponseValue;
24617 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24619 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
24620 if(!isWasmInitialized) {
24621 throw new Error("initializeWasm() must be awaited first!");
24623 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
24624 return nativeResponseValue;
24626 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24628 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
24629 if(!isWasmInitialized) {
24630 throw new Error("initializeWasm() must be awaited first!");
24632 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
24633 return nativeResponseValue;
24635 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24637 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
24638 if(!isWasmInitialized) {
24639 throw new Error("initializeWasm() must be awaited first!");
24641 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
24642 return nativeResponseValue;
24644 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
24646 export function ErroringMessageHandler_free(this_obj: number): void {
24647 if(!isWasmInitialized) {
24648 throw new Error("initializeWasm() must be awaited first!");
24650 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
24651 // debug statements here
24653 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
24655 export function ErroringMessageHandler_new(): number {
24656 if(!isWasmInitialized) {
24657 throw new Error("initializeWasm() must be awaited first!");
24659 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
24660 return nativeResponseValue;
24662 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24664 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24665 if(!isWasmInitialized) {
24666 throw new Error("initializeWasm() must be awaited first!");
24668 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
24669 return nativeResponseValue;
24671 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24673 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
24674 if(!isWasmInitialized) {
24675 throw new Error("initializeWasm() must be awaited first!");
24677 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
24678 return nativeResponseValue;
24680 // void MessageHandler_free(struct LDKMessageHandler this_obj);
24682 export function MessageHandler_free(this_obj: number): void {
24683 if(!isWasmInitialized) {
24684 throw new Error("initializeWasm() must be awaited first!");
24686 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
24687 // debug statements here
24689 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24691 export function MessageHandler_get_chan_handler(this_ptr: number): number {
24692 if(!isWasmInitialized) {
24693 throw new Error("initializeWasm() must be awaited first!");
24695 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
24696 return nativeResponseValue;
24698 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
24700 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
24701 if(!isWasmInitialized) {
24702 throw new Error("initializeWasm() must be awaited first!");
24704 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
24705 // debug statements here
24707 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24709 export function MessageHandler_get_route_handler(this_ptr: number): number {
24710 if(!isWasmInitialized) {
24711 throw new Error("initializeWasm() must be awaited first!");
24713 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
24714 return nativeResponseValue;
24716 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
24718 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
24719 if(!isWasmInitialized) {
24720 throw new Error("initializeWasm() must be awaited first!");
24722 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
24723 // debug statements here
24725 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
24727 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
24728 if(!isWasmInitialized) {
24729 throw new Error("initializeWasm() must be awaited first!");
24731 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
24732 return nativeResponseValue;
24734 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
24736 export function SocketDescriptor_clone_ptr(arg: number): number {
24737 if(!isWasmInitialized) {
24738 throw new Error("initializeWasm() must be awaited first!");
24740 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
24741 return nativeResponseValue;
24743 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
24745 export function SocketDescriptor_clone(orig: number): number {
24746 if(!isWasmInitialized) {
24747 throw new Error("initializeWasm() must be awaited first!");
24749 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
24750 return nativeResponseValue;
24752 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
24754 export function SocketDescriptor_free(this_ptr: number): void {
24755 if(!isWasmInitialized) {
24756 throw new Error("initializeWasm() must be awaited first!");
24758 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
24759 // debug statements here
24761 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
24763 export function PeerHandleError_free(this_obj: number): void {
24764 if(!isWasmInitialized) {
24765 throw new Error("initializeWasm() must be awaited first!");
24767 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
24768 // debug statements here
24770 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
24772 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
24773 if(!isWasmInitialized) {
24774 throw new Error("initializeWasm() must be awaited first!");
24776 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
24777 return nativeResponseValue;
24779 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
24781 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
24782 if(!isWasmInitialized) {
24783 throw new Error("initializeWasm() must be awaited first!");
24785 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
24786 // debug statements here
24788 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
24790 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
24791 if(!isWasmInitialized) {
24792 throw new Error("initializeWasm() must be awaited first!");
24794 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
24795 return nativeResponseValue;
24797 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
24799 export function PeerHandleError_clone_ptr(arg: number): number {
24800 if(!isWasmInitialized) {
24801 throw new Error("initializeWasm() must be awaited first!");
24803 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
24804 return nativeResponseValue;
24806 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
24808 export function PeerHandleError_clone(orig: number): number {
24809 if(!isWasmInitialized) {
24810 throw new Error("initializeWasm() must be awaited first!");
24812 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
24813 return nativeResponseValue;
24815 // void PeerManager_free(struct LDKPeerManager this_obj);
24817 export function PeerManager_free(this_obj: number): void {
24818 if(!isWasmInitialized) {
24819 throw new Error("initializeWasm() must be awaited first!");
24821 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
24822 // debug statements here
24824 // 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);
24826 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
24827 if(!isWasmInitialized) {
24828 throw new Error("initializeWasm() must be awaited first!");
24830 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
24831 return nativeResponseValue;
24833 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
24835 export function PeerManager_get_peer_node_ids(this_arg: number): number {
24836 if(!isWasmInitialized) {
24837 throw new Error("initializeWasm() must be awaited first!");
24839 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
24840 return nativeResponseValue;
24842 // 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, struct LDKCOption_NetAddressZ remote_network_address);
24844 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
24845 if(!isWasmInitialized) {
24846 throw new Error("initializeWasm() must be awaited first!");
24848 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
24849 return nativeResponseValue;
24851 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_new_inbound_connection(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor descriptor, struct LDKCOption_NetAddressZ remote_network_address);
24853 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
24854 if(!isWasmInitialized) {
24855 throw new Error("initializeWasm() must be awaited first!");
24857 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
24858 return nativeResponseValue;
24860 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24862 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
24863 if(!isWasmInitialized) {
24864 throw new Error("initializeWasm() must be awaited first!");
24866 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
24867 return nativeResponseValue;
24869 // 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);
24871 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
24872 if(!isWasmInitialized) {
24873 throw new Error("initializeWasm() must be awaited first!");
24875 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
24876 return nativeResponseValue;
24878 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
24880 export function PeerManager_process_events(this_arg: number): void {
24881 if(!isWasmInitialized) {
24882 throw new Error("initializeWasm() must be awaited first!");
24884 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
24885 // debug statements here
24887 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24889 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
24890 if(!isWasmInitialized) {
24891 throw new Error("initializeWasm() must be awaited first!");
24893 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
24894 // debug statements here
24896 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
24898 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
24899 if(!isWasmInitialized) {
24900 throw new Error("initializeWasm() must be awaited first!");
24902 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
24903 // debug statements here
24905 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
24907 export function PeerManager_disconnect_all_peers(this_arg: number): void {
24908 if(!isWasmInitialized) {
24909 throw new Error("initializeWasm() must be awaited first!");
24911 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
24912 // debug statements here
24914 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
24916 export function PeerManager_timer_tick_occurred(this_arg: number): void {
24917 if(!isWasmInitialized) {
24918 throw new Error("initializeWasm() must be awaited first!");
24920 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
24921 // debug statements here
24923 // uint64_t htlc_success_tx_weight(bool opt_anchors);
24925 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
24926 if(!isWasmInitialized) {
24927 throw new Error("initializeWasm() must be awaited first!");
24929 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
24930 return nativeResponseValue;
24932 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
24934 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
24935 if(!isWasmInitialized) {
24936 throw new Error("initializeWasm() must be awaited first!");
24938 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
24939 return nativeResponseValue;
24941 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
24943 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
24944 if(!isWasmInitialized) {
24945 throw new Error("initializeWasm() must be awaited first!");
24947 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
24948 return nativeResponseValue;
24950 // 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);
24952 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 {
24953 if(!isWasmInitialized) {
24954 throw new Error("initializeWasm() must be awaited first!");
24956 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
24957 return nativeResponseValue;
24959 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
24961 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
24962 if(!isWasmInitialized) {
24963 throw new Error("initializeWasm() must be awaited first!");
24965 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
24966 // debug statements here
24968 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
24970 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
24971 if(!isWasmInitialized) {
24972 throw new Error("initializeWasm() must be awaited first!");
24974 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
24975 return nativeResponseValue;
24977 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
24979 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
24980 if(!isWasmInitialized) {
24981 throw new Error("initializeWasm() must be awaited first!");
24983 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
24984 return nativeResponseValue;
24986 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
24988 export function CounterpartyCommitmentSecrets_new(): number {
24989 if(!isWasmInitialized) {
24990 throw new Error("initializeWasm() must be awaited first!");
24992 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
24993 return nativeResponseValue;
24995 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
24997 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
24998 if(!isWasmInitialized) {
24999 throw new Error("initializeWasm() must be awaited first!");
25001 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25002 return nativeResponseValue;
25004 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25006 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
25007 if(!isWasmInitialized) {
25008 throw new Error("initializeWasm() must be awaited first!");
25010 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25011 return nativeResponseValue;
25013 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25015 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
25016 if(!isWasmInitialized) {
25017 throw new Error("initializeWasm() must be awaited first!");
25019 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25020 return nativeResponseValue;
25022 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25024 export function CounterpartyCommitmentSecrets_write(obj: number): number {
25025 if(!isWasmInitialized) {
25026 throw new Error("initializeWasm() must be awaited first!");
25028 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25029 return nativeResponseValue;
25031 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25033 export function CounterpartyCommitmentSecrets_read(ser: number): number {
25034 if(!isWasmInitialized) {
25035 throw new Error("initializeWasm() must be awaited first!");
25037 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25038 return nativeResponseValue;
25040 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25042 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
25043 if(!isWasmInitialized) {
25044 throw new Error("initializeWasm() must be awaited first!");
25046 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25047 return nativeResponseValue;
25049 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25051 export function derive_public_key(per_commitment_point: number, base_point: number): number {
25052 if(!isWasmInitialized) {
25053 throw new Error("initializeWasm() must be awaited first!");
25055 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25056 return nativeResponseValue;
25058 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25060 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
25061 if(!isWasmInitialized) {
25062 throw new Error("initializeWasm() must be awaited first!");
25064 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25065 return nativeResponseValue;
25067 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25069 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
25070 if(!isWasmInitialized) {
25071 throw new Error("initializeWasm() must be awaited first!");
25073 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25074 return nativeResponseValue;
25076 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25078 export function TxCreationKeys_free(this_obj: number): void {
25079 if(!isWasmInitialized) {
25080 throw new Error("initializeWasm() must be awaited first!");
25082 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25083 // debug statements here
25085 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25087 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
25088 if(!isWasmInitialized) {
25089 throw new Error("initializeWasm() must be awaited first!");
25091 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25092 return nativeResponseValue;
25094 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25096 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
25097 if(!isWasmInitialized) {
25098 throw new Error("initializeWasm() must be awaited first!");
25100 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25101 // debug statements here
25103 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25105 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
25106 if(!isWasmInitialized) {
25107 throw new Error("initializeWasm() must be awaited first!");
25109 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25110 return nativeResponseValue;
25112 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25114 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
25115 if(!isWasmInitialized) {
25116 throw new Error("initializeWasm() must be awaited first!");
25118 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25119 // debug statements here
25121 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25123 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
25124 if(!isWasmInitialized) {
25125 throw new Error("initializeWasm() must be awaited first!");
25127 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25128 return nativeResponseValue;
25130 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25132 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
25133 if(!isWasmInitialized) {
25134 throw new Error("initializeWasm() must be awaited first!");
25136 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
25137 // debug statements here
25139 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25141 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
25142 if(!isWasmInitialized) {
25143 throw new Error("initializeWasm() must be awaited first!");
25145 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
25146 return nativeResponseValue;
25148 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25150 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
25151 if(!isWasmInitialized) {
25152 throw new Error("initializeWasm() must be awaited first!");
25154 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
25155 // debug statements here
25157 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25159 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
25160 if(!isWasmInitialized) {
25161 throw new Error("initializeWasm() must be awaited first!");
25163 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
25164 return nativeResponseValue;
25166 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25168 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
25169 if(!isWasmInitialized) {
25170 throw new Error("initializeWasm() must be awaited first!");
25172 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
25173 // debug statements here
25175 // 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);
25177 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 {
25178 if(!isWasmInitialized) {
25179 throw new Error("initializeWasm() must be awaited first!");
25181 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);
25182 return nativeResponseValue;
25184 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
25186 export function TxCreationKeys_clone_ptr(arg: number): number {
25187 if(!isWasmInitialized) {
25188 throw new Error("initializeWasm() must be awaited first!");
25190 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
25191 return nativeResponseValue;
25193 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
25195 export function TxCreationKeys_clone(orig: number): number {
25196 if(!isWasmInitialized) {
25197 throw new Error("initializeWasm() must be awaited first!");
25199 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
25200 return nativeResponseValue;
25202 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
25204 export function TxCreationKeys_write(obj: number): number {
25205 if(!isWasmInitialized) {
25206 throw new Error("initializeWasm() must be awaited first!");
25208 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
25209 return nativeResponseValue;
25211 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
25213 export function TxCreationKeys_read(ser: number): number {
25214 if(!isWasmInitialized) {
25215 throw new Error("initializeWasm() must be awaited first!");
25217 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
25218 return nativeResponseValue;
25220 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
25222 export function ChannelPublicKeys_free(this_obj: number): void {
25223 if(!isWasmInitialized) {
25224 throw new Error("initializeWasm() must be awaited first!");
25226 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
25227 // debug statements here
25229 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25231 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
25232 if(!isWasmInitialized) {
25233 throw new Error("initializeWasm() must be awaited first!");
25235 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
25236 return nativeResponseValue;
25238 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25240 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
25241 if(!isWasmInitialized) {
25242 throw new Error("initializeWasm() must be awaited first!");
25244 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
25245 // debug statements here
25247 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25249 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
25250 if(!isWasmInitialized) {
25251 throw new Error("initializeWasm() must be awaited first!");
25253 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
25254 return nativeResponseValue;
25256 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25258 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
25259 if(!isWasmInitialized) {
25260 throw new Error("initializeWasm() must be awaited first!");
25262 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
25263 // debug statements here
25265 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25267 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
25268 if(!isWasmInitialized) {
25269 throw new Error("initializeWasm() must be awaited first!");
25271 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
25272 return nativeResponseValue;
25274 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25276 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
25277 if(!isWasmInitialized) {
25278 throw new Error("initializeWasm() must be awaited first!");
25280 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
25281 // debug statements here
25283 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25285 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
25286 if(!isWasmInitialized) {
25287 throw new Error("initializeWasm() must be awaited first!");
25289 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
25290 return nativeResponseValue;
25292 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25294 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
25295 if(!isWasmInitialized) {
25296 throw new Error("initializeWasm() must be awaited first!");
25298 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
25299 // debug statements here
25301 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25303 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
25304 if(!isWasmInitialized) {
25305 throw new Error("initializeWasm() must be awaited first!");
25307 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
25308 return nativeResponseValue;
25310 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25312 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
25313 if(!isWasmInitialized) {
25314 throw new Error("initializeWasm() must be awaited first!");
25316 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
25317 // debug statements here
25319 // 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);
25321 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 {
25322 if(!isWasmInitialized) {
25323 throw new Error("initializeWasm() must be awaited first!");
25325 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
25326 return nativeResponseValue;
25328 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
25330 export function ChannelPublicKeys_clone_ptr(arg: number): number {
25331 if(!isWasmInitialized) {
25332 throw new Error("initializeWasm() must be awaited first!");
25334 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
25335 return nativeResponseValue;
25337 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
25339 export function ChannelPublicKeys_clone(orig: number): number {
25340 if(!isWasmInitialized) {
25341 throw new Error("initializeWasm() must be awaited first!");
25343 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
25344 return nativeResponseValue;
25346 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
25348 export function ChannelPublicKeys_write(obj: number): number {
25349 if(!isWasmInitialized) {
25350 throw new Error("initializeWasm() must be awaited first!");
25352 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
25353 return nativeResponseValue;
25355 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
25357 export function ChannelPublicKeys_read(ser: number): number {
25358 if(!isWasmInitialized) {
25359 throw new Error("initializeWasm() must be awaited first!");
25361 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
25362 return nativeResponseValue;
25364 // 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);
25366 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 {
25367 if(!isWasmInitialized) {
25368 throw new Error("initializeWasm() must be awaited first!");
25370 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
25371 return nativeResponseValue;
25373 // 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);
25375 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
25376 if(!isWasmInitialized) {
25377 throw new Error("initializeWasm() must be awaited first!");
25379 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
25380 return nativeResponseValue;
25382 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
25384 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
25385 if(!isWasmInitialized) {
25386 throw new Error("initializeWasm() must be awaited first!");
25388 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
25389 return nativeResponseValue;
25391 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
25393 export function HTLCOutputInCommitment_free(this_obj: number): void {
25394 if(!isWasmInitialized) {
25395 throw new Error("initializeWasm() must be awaited first!");
25397 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
25398 // debug statements here
25400 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25402 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
25403 if(!isWasmInitialized) {
25404 throw new Error("initializeWasm() must be awaited first!");
25406 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
25407 return nativeResponseValue;
25409 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
25411 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
25412 if(!isWasmInitialized) {
25413 throw new Error("initializeWasm() must be awaited first!");
25415 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
25416 // debug statements here
25418 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25420 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
25421 if(!isWasmInitialized) {
25422 throw new Error("initializeWasm() must be awaited first!");
25424 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
25425 return nativeResponseValue;
25427 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
25429 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
25430 if(!isWasmInitialized) {
25431 throw new Error("initializeWasm() must be awaited first!");
25433 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
25434 // debug statements here
25436 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25438 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
25439 if(!isWasmInitialized) {
25440 throw new Error("initializeWasm() must be awaited first!");
25442 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
25443 return nativeResponseValue;
25445 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
25447 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
25448 if(!isWasmInitialized) {
25449 throw new Error("initializeWasm() must be awaited first!");
25451 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
25452 // debug statements here
25454 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
25456 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
25457 if(!isWasmInitialized) {
25458 throw new Error("initializeWasm() must be awaited first!");
25460 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
25461 return nativeResponseValue;
25463 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25465 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
25466 if(!isWasmInitialized) {
25467 throw new Error("initializeWasm() must be awaited first!");
25469 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
25470 // debug statements here
25472 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25474 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
25475 if(!isWasmInitialized) {
25476 throw new Error("initializeWasm() must be awaited first!");
25478 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
25479 return nativeResponseValue;
25481 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
25483 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
25484 if(!isWasmInitialized) {
25485 throw new Error("initializeWasm() must be awaited first!");
25487 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
25488 // debug statements here
25490 // 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);
25492 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 {
25493 if(!isWasmInitialized) {
25494 throw new Error("initializeWasm() must be awaited first!");
25496 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
25497 return nativeResponseValue;
25499 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
25501 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
25502 if(!isWasmInitialized) {
25503 throw new Error("initializeWasm() must be awaited first!");
25505 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
25506 return nativeResponseValue;
25508 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
25510 export function HTLCOutputInCommitment_clone(orig: number): number {
25511 if(!isWasmInitialized) {
25512 throw new Error("initializeWasm() must be awaited first!");
25514 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
25515 return nativeResponseValue;
25517 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
25519 export function HTLCOutputInCommitment_write(obj: number): number {
25520 if(!isWasmInitialized) {
25521 throw new Error("initializeWasm() must be awaited first!");
25523 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
25524 return nativeResponseValue;
25526 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
25528 export function HTLCOutputInCommitment_read(ser: number): number {
25529 if(!isWasmInitialized) {
25530 throw new Error("initializeWasm() must be awaited first!");
25532 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
25533 return nativeResponseValue;
25535 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
25537 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
25538 if(!isWasmInitialized) {
25539 throw new Error("initializeWasm() must be awaited first!");
25541 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
25542 return nativeResponseValue;
25544 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
25546 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
25547 if(!isWasmInitialized) {
25548 throw new Error("initializeWasm() must be awaited first!");
25550 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
25551 return nativeResponseValue;
25553 // 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);
25555 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 {
25556 if(!isWasmInitialized) {
25557 throw new Error("initializeWasm() must be awaited first!");
25559 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
25560 return nativeResponseValue;
25562 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
25564 export function get_anchor_redeemscript(funding_pubkey: number): number {
25565 if(!isWasmInitialized) {
25566 throw new Error("initializeWasm() must be awaited first!");
25568 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
25569 return nativeResponseValue;
25571 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
25573 export function ChannelTransactionParameters_free(this_obj: number): void {
25574 if(!isWasmInitialized) {
25575 throw new Error("initializeWasm() must be awaited first!");
25577 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
25578 // debug statements here
25580 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25582 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
25583 if(!isWasmInitialized) {
25584 throw new Error("initializeWasm() must be awaited first!");
25586 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
25587 return nativeResponseValue;
25589 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25591 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
25592 if(!isWasmInitialized) {
25593 throw new Error("initializeWasm() must be awaited first!");
25595 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
25596 // debug statements here
25598 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25600 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
25601 if(!isWasmInitialized) {
25602 throw new Error("initializeWasm() must be awaited first!");
25604 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
25605 return nativeResponseValue;
25607 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25609 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
25610 if(!isWasmInitialized) {
25611 throw new Error("initializeWasm() must be awaited first!");
25613 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
25614 // debug statements here
25616 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25618 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
25619 if(!isWasmInitialized) {
25620 throw new Error("initializeWasm() must be awaited first!");
25622 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
25623 return nativeResponseValue;
25625 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
25627 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
25628 if(!isWasmInitialized) {
25629 throw new Error("initializeWasm() must be awaited first!");
25631 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
25632 // debug statements here
25634 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25636 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
25637 if(!isWasmInitialized) {
25638 throw new Error("initializeWasm() must be awaited first!");
25640 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
25641 return nativeResponseValue;
25643 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
25645 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
25646 if(!isWasmInitialized) {
25647 throw new Error("initializeWasm() must be awaited first!");
25649 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
25650 // debug statements here
25652 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25654 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
25655 if(!isWasmInitialized) {
25656 throw new Error("initializeWasm() must be awaited first!");
25658 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
25659 return nativeResponseValue;
25661 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
25663 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
25664 if(!isWasmInitialized) {
25665 throw new Error("initializeWasm() must be awaited first!");
25667 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
25668 // debug statements here
25670 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25672 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
25673 if(!isWasmInitialized) {
25674 throw new Error("initializeWasm() must be awaited first!");
25676 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
25677 return nativeResponseValue;
25679 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
25681 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
25682 if(!isWasmInitialized) {
25683 throw new Error("initializeWasm() must be awaited first!");
25685 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
25686 // debug statements here
25688 // 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);
25690 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 {
25691 if(!isWasmInitialized) {
25692 throw new Error("initializeWasm() must be awaited first!");
25694 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);
25695 return nativeResponseValue;
25697 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
25699 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
25700 if(!isWasmInitialized) {
25701 throw new Error("initializeWasm() must be awaited first!");
25703 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
25704 return nativeResponseValue;
25706 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
25708 export function ChannelTransactionParameters_clone(orig: number): number {
25709 if(!isWasmInitialized) {
25710 throw new Error("initializeWasm() must be awaited first!");
25712 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
25713 return nativeResponseValue;
25715 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
25717 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
25718 if(!isWasmInitialized) {
25719 throw new Error("initializeWasm() must be awaited first!");
25721 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
25722 // debug statements here
25724 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25726 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
25727 if(!isWasmInitialized) {
25728 throw new Error("initializeWasm() must be awaited first!");
25730 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
25731 return nativeResponseValue;
25733 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25735 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
25736 if(!isWasmInitialized) {
25737 throw new Error("initializeWasm() must be awaited first!");
25739 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
25740 // debug statements here
25742 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25744 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
25745 if(!isWasmInitialized) {
25746 throw new Error("initializeWasm() must be awaited first!");
25748 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
25749 return nativeResponseValue;
25751 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25753 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
25754 if(!isWasmInitialized) {
25755 throw new Error("initializeWasm() must be awaited first!");
25757 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
25758 // debug statements here
25760 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
25762 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
25763 if(!isWasmInitialized) {
25764 throw new Error("initializeWasm() must be awaited first!");
25766 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
25767 return nativeResponseValue;
25769 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
25771 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
25772 if(!isWasmInitialized) {
25773 throw new Error("initializeWasm() must be awaited first!");
25775 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
25776 return nativeResponseValue;
25778 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
25780 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
25781 if(!isWasmInitialized) {
25782 throw new Error("initializeWasm() must be awaited first!");
25784 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
25785 return nativeResponseValue;
25787 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25789 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
25790 if(!isWasmInitialized) {
25791 throw new Error("initializeWasm() must be awaited first!");
25793 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
25794 return nativeResponseValue;
25796 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25798 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
25799 if(!isWasmInitialized) {
25800 throw new Error("initializeWasm() must be awaited first!");
25802 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
25803 return nativeResponseValue;
25805 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25807 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
25808 if(!isWasmInitialized) {
25809 throw new Error("initializeWasm() must be awaited first!");
25811 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
25812 return nativeResponseValue;
25814 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
25816 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
25817 if(!isWasmInitialized) {
25818 throw new Error("initializeWasm() must be awaited first!");
25820 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
25821 return nativeResponseValue;
25823 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
25825 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
25826 if(!isWasmInitialized) {
25827 throw new Error("initializeWasm() must be awaited first!");
25829 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
25830 return nativeResponseValue;
25832 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
25834 export function ChannelTransactionParameters_write(obj: number): number {
25835 if(!isWasmInitialized) {
25836 throw new Error("initializeWasm() must be awaited first!");
25838 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
25839 return nativeResponseValue;
25841 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
25843 export function ChannelTransactionParameters_read(ser: number): number {
25844 if(!isWasmInitialized) {
25845 throw new Error("initializeWasm() must be awaited first!");
25847 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
25848 return nativeResponseValue;
25850 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
25852 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
25853 if(!isWasmInitialized) {
25854 throw new Error("initializeWasm() must be awaited first!");
25856 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
25857 // debug statements here
25859 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25861 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
25862 if(!isWasmInitialized) {
25863 throw new Error("initializeWasm() must be awaited first!");
25865 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
25866 return nativeResponseValue;
25868 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25870 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
25871 if(!isWasmInitialized) {
25872 throw new Error("initializeWasm() must be awaited first!");
25874 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
25875 return nativeResponseValue;
25877 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25879 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
25880 if(!isWasmInitialized) {
25881 throw new Error("initializeWasm() must be awaited first!");
25883 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
25884 return nativeResponseValue;
25886 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25888 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
25889 if(!isWasmInitialized) {
25890 throw new Error("initializeWasm() must be awaited first!");
25892 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
25893 return nativeResponseValue;
25895 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25897 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
25898 if(!isWasmInitialized) {
25899 throw new Error("initializeWasm() must be awaited first!");
25901 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
25902 return nativeResponseValue;
25904 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25906 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
25907 if(!isWasmInitialized) {
25908 throw new Error("initializeWasm() must be awaited first!");
25910 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
25911 return nativeResponseValue;
25913 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
25915 export function HolderCommitmentTransaction_free(this_obj: number): void {
25916 if(!isWasmInitialized) {
25917 throw new Error("initializeWasm() must be awaited first!");
25919 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
25920 // debug statements here
25922 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
25924 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
25925 if(!isWasmInitialized) {
25926 throw new Error("initializeWasm() must be awaited first!");
25928 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
25929 return nativeResponseValue;
25931 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
25933 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
25934 if(!isWasmInitialized) {
25935 throw new Error("initializeWasm() must be awaited first!");
25937 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
25938 // debug statements here
25940 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
25942 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
25943 if(!isWasmInitialized) {
25944 throw new Error("initializeWasm() must be awaited first!");
25946 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
25947 // debug statements here
25949 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
25951 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
25952 if(!isWasmInitialized) {
25953 throw new Error("initializeWasm() must be awaited first!");
25955 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
25956 return nativeResponseValue;
25958 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
25960 export function HolderCommitmentTransaction_clone(orig: number): number {
25961 if(!isWasmInitialized) {
25962 throw new Error("initializeWasm() must be awaited first!");
25964 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
25965 return nativeResponseValue;
25967 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
25969 export function HolderCommitmentTransaction_write(obj: number): number {
25970 if(!isWasmInitialized) {
25971 throw new Error("initializeWasm() must be awaited first!");
25973 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
25974 return nativeResponseValue;
25976 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
25978 export function HolderCommitmentTransaction_read(ser: number): number {
25979 if(!isWasmInitialized) {
25980 throw new Error("initializeWasm() must be awaited first!");
25982 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
25983 return nativeResponseValue;
25985 // 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);
25987 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
25988 if(!isWasmInitialized) {
25989 throw new Error("initializeWasm() must be awaited first!");
25991 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
25992 return nativeResponseValue;
25994 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
25996 export function BuiltCommitmentTransaction_free(this_obj: number): void {
25997 if(!isWasmInitialized) {
25998 throw new Error("initializeWasm() must be awaited first!");
26000 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
26001 // debug statements here
26003 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26005 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
26006 if(!isWasmInitialized) {
26007 throw new Error("initializeWasm() must be awaited first!");
26009 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26010 return nativeResponseValue;
26012 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26014 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
26015 if(!isWasmInitialized) {
26016 throw new Error("initializeWasm() must be awaited first!");
26018 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26019 // debug statements here
26021 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26023 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
26024 if(!isWasmInitialized) {
26025 throw new Error("initializeWasm() must be awaited first!");
26027 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26028 return nativeResponseValue;
26030 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26032 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
26033 if(!isWasmInitialized) {
26034 throw new Error("initializeWasm() must be awaited first!");
26036 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26037 // debug statements here
26039 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26041 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
26042 if(!isWasmInitialized) {
26043 throw new Error("initializeWasm() must be awaited first!");
26045 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26046 return nativeResponseValue;
26048 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26050 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
26051 if(!isWasmInitialized) {
26052 throw new Error("initializeWasm() must be awaited first!");
26054 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26055 return nativeResponseValue;
26057 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26059 export function BuiltCommitmentTransaction_clone(orig: number): number {
26060 if(!isWasmInitialized) {
26061 throw new Error("initializeWasm() must be awaited first!");
26063 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26064 return nativeResponseValue;
26066 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26068 export function BuiltCommitmentTransaction_write(obj: number): number {
26069 if(!isWasmInitialized) {
26070 throw new Error("initializeWasm() must be awaited first!");
26072 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26073 return nativeResponseValue;
26075 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26077 export function BuiltCommitmentTransaction_read(ser: number): number {
26078 if(!isWasmInitialized) {
26079 throw new Error("initializeWasm() must be awaited first!");
26081 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26082 return nativeResponseValue;
26084 // 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);
26086 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26087 if(!isWasmInitialized) {
26088 throw new Error("initializeWasm() must be awaited first!");
26090 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26091 return nativeResponseValue;
26093 // 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);
26095 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26096 if(!isWasmInitialized) {
26097 throw new Error("initializeWasm() must be awaited first!");
26099 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26100 return nativeResponseValue;
26102 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26104 export function ClosingTransaction_free(this_obj: number): void {
26105 if(!isWasmInitialized) {
26106 throw new Error("initializeWasm() must be awaited first!");
26108 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26109 // debug statements here
26111 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26113 export function ClosingTransaction_clone_ptr(arg: number): number {
26114 if(!isWasmInitialized) {
26115 throw new Error("initializeWasm() must be awaited first!");
26117 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26118 return nativeResponseValue;
26120 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
26122 export function ClosingTransaction_clone(orig: number): number {
26123 if(!isWasmInitialized) {
26124 throw new Error("initializeWasm() must be awaited first!");
26126 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
26127 return nativeResponseValue;
26129 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
26131 export function ClosingTransaction_hash(o: number): bigint {
26132 if(!isWasmInitialized) {
26133 throw new Error("initializeWasm() must be awaited first!");
26135 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
26136 return nativeResponseValue;
26138 // 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);
26140 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 {
26141 if(!isWasmInitialized) {
26142 throw new Error("initializeWasm() must be awaited first!");
26144 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
26145 return nativeResponseValue;
26147 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26149 export function ClosingTransaction_trust(this_arg: number): number {
26150 if(!isWasmInitialized) {
26151 throw new Error("initializeWasm() must be awaited first!");
26153 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
26154 return nativeResponseValue;
26156 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
26158 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
26159 if(!isWasmInitialized) {
26160 throw new Error("initializeWasm() must be awaited first!");
26162 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
26163 return nativeResponseValue;
26165 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26167 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
26168 if(!isWasmInitialized) {
26169 throw new Error("initializeWasm() must be awaited first!");
26171 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
26172 return nativeResponseValue;
26174 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26176 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
26177 if(!isWasmInitialized) {
26178 throw new Error("initializeWasm() must be awaited first!");
26180 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
26181 return nativeResponseValue;
26183 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26185 export function ClosingTransaction_to_holder_script(this_arg: number): number {
26186 if(!isWasmInitialized) {
26187 throw new Error("initializeWasm() must be awaited first!");
26189 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
26190 return nativeResponseValue;
26192 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26194 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
26195 if(!isWasmInitialized) {
26196 throw new Error("initializeWasm() must be awaited first!");
26198 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
26199 return nativeResponseValue;
26201 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
26203 export function TrustedClosingTransaction_free(this_obj: number): void {
26204 if(!isWasmInitialized) {
26205 throw new Error("initializeWasm() must be awaited first!");
26207 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
26208 // debug statements here
26210 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
26212 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
26213 if(!isWasmInitialized) {
26214 throw new Error("initializeWasm() must be awaited first!");
26216 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
26217 return nativeResponseValue;
26219 // 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);
26221 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26222 if(!isWasmInitialized) {
26223 throw new Error("initializeWasm() must be awaited first!");
26225 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26226 return nativeResponseValue;
26228 // 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);
26230 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26231 if(!isWasmInitialized) {
26232 throw new Error("initializeWasm() must be awaited first!");
26234 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26235 return nativeResponseValue;
26237 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
26239 export function CommitmentTransaction_free(this_obj: number): void {
26240 if(!isWasmInitialized) {
26241 throw new Error("initializeWasm() must be awaited first!");
26243 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
26244 // debug statements here
26246 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
26248 export function CommitmentTransaction_clone_ptr(arg: number): number {
26249 if(!isWasmInitialized) {
26250 throw new Error("initializeWasm() must be awaited first!");
26252 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
26253 return nativeResponseValue;
26255 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
26257 export function CommitmentTransaction_clone(orig: number): number {
26258 if(!isWasmInitialized) {
26259 throw new Error("initializeWasm() must be awaited first!");
26261 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
26262 return nativeResponseValue;
26264 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
26266 export function CommitmentTransaction_write(obj: number): number {
26267 if(!isWasmInitialized) {
26268 throw new Error("initializeWasm() must be awaited first!");
26270 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
26271 return nativeResponseValue;
26273 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
26275 export function CommitmentTransaction_read(ser: number): number {
26276 if(!isWasmInitialized) {
26277 throw new Error("initializeWasm() must be awaited first!");
26279 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
26280 return nativeResponseValue;
26282 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26284 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
26285 if(!isWasmInitialized) {
26286 throw new Error("initializeWasm() must be awaited first!");
26288 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
26289 return nativeResponseValue;
26291 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26293 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
26294 if(!isWasmInitialized) {
26295 throw new Error("initializeWasm() must be awaited first!");
26297 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
26298 return nativeResponseValue;
26300 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26302 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
26303 if(!isWasmInitialized) {
26304 throw new Error("initializeWasm() must be awaited first!");
26306 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
26307 return nativeResponseValue;
26309 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26311 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
26312 if(!isWasmInitialized) {
26313 throw new Error("initializeWasm() must be awaited first!");
26315 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
26316 return nativeResponseValue;
26318 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26320 export function CommitmentTransaction_trust(this_arg: number): number {
26321 if(!isWasmInitialized) {
26322 throw new Error("initializeWasm() must be awaited first!");
26324 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
26325 return nativeResponseValue;
26327 // 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);
26329 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
26330 if(!isWasmInitialized) {
26331 throw new Error("initializeWasm() must be awaited first!");
26333 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
26334 return nativeResponseValue;
26336 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
26338 export function TrustedCommitmentTransaction_free(this_obj: number): void {
26339 if(!isWasmInitialized) {
26340 throw new Error("initializeWasm() must be awaited first!");
26342 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
26343 // debug statements here
26345 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26347 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
26348 if(!isWasmInitialized) {
26349 throw new Error("initializeWasm() must be awaited first!");
26351 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
26352 return nativeResponseValue;
26354 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26356 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
26357 if(!isWasmInitialized) {
26358 throw new Error("initializeWasm() must be awaited first!");
26360 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
26361 return nativeResponseValue;
26363 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26365 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
26366 if(!isWasmInitialized) {
26367 throw new Error("initializeWasm() must be awaited first!");
26369 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
26370 return nativeResponseValue;
26372 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26374 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
26375 if(!isWasmInitialized) {
26376 throw new Error("initializeWasm() must be awaited first!");
26378 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
26379 return nativeResponseValue;
26381 // 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);
26383 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
26384 if(!isWasmInitialized) {
26385 throw new Error("initializeWasm() must be awaited first!");
26387 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
26388 return nativeResponseValue;
26390 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
26392 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
26393 if(!isWasmInitialized) {
26394 throw new Error("initializeWasm() must be awaited first!");
26396 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
26397 return nativeResponseValue;
26399 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
26401 export function InitFeatures_eq(a: number, b: number): boolean {
26402 if(!isWasmInitialized) {
26403 throw new Error("initializeWasm() must be awaited first!");
26405 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
26406 return nativeResponseValue;
26408 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
26410 export function NodeFeatures_eq(a: number, b: number): boolean {
26411 if(!isWasmInitialized) {
26412 throw new Error("initializeWasm() must be awaited first!");
26414 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
26415 return nativeResponseValue;
26417 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
26419 export function ChannelFeatures_eq(a: number, b: number): boolean {
26420 if(!isWasmInitialized) {
26421 throw new Error("initializeWasm() must be awaited first!");
26423 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
26424 return nativeResponseValue;
26426 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
26428 export function InvoiceFeatures_eq(a: number, b: number): boolean {
26429 if(!isWasmInitialized) {
26430 throw new Error("initializeWasm() must be awaited first!");
26432 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
26433 return nativeResponseValue;
26435 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
26437 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
26438 if(!isWasmInitialized) {
26439 throw new Error("initializeWasm() must be awaited first!");
26441 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
26442 return nativeResponseValue;
26444 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
26446 export function InitFeatures_clone_ptr(arg: number): number {
26447 if(!isWasmInitialized) {
26448 throw new Error("initializeWasm() must be awaited first!");
26450 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
26451 return nativeResponseValue;
26453 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
26455 export function InitFeatures_clone(orig: number): number {
26456 if(!isWasmInitialized) {
26457 throw new Error("initializeWasm() must be awaited first!");
26459 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
26460 return nativeResponseValue;
26462 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
26464 export function NodeFeatures_clone_ptr(arg: number): number {
26465 if(!isWasmInitialized) {
26466 throw new Error("initializeWasm() must be awaited first!");
26468 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
26469 return nativeResponseValue;
26471 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
26473 export function NodeFeatures_clone(orig: number): number {
26474 if(!isWasmInitialized) {
26475 throw new Error("initializeWasm() must be awaited first!");
26477 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
26478 return nativeResponseValue;
26480 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
26482 export function ChannelFeatures_clone_ptr(arg: number): number {
26483 if(!isWasmInitialized) {
26484 throw new Error("initializeWasm() must be awaited first!");
26486 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
26487 return nativeResponseValue;
26489 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
26491 export function ChannelFeatures_clone(orig: number): number {
26492 if(!isWasmInitialized) {
26493 throw new Error("initializeWasm() must be awaited first!");
26495 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
26496 return nativeResponseValue;
26498 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
26500 export function InvoiceFeatures_clone_ptr(arg: number): number {
26501 if(!isWasmInitialized) {
26502 throw new Error("initializeWasm() must be awaited first!");
26504 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
26505 return nativeResponseValue;
26507 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
26509 export function InvoiceFeatures_clone(orig: number): number {
26510 if(!isWasmInitialized) {
26511 throw new Error("initializeWasm() must be awaited first!");
26513 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
26514 return nativeResponseValue;
26516 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
26518 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
26519 if(!isWasmInitialized) {
26520 throw new Error("initializeWasm() must be awaited first!");
26522 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
26523 return nativeResponseValue;
26525 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
26527 export function ChannelTypeFeatures_clone(orig: number): number {
26528 if(!isWasmInitialized) {
26529 throw new Error("initializeWasm() must be awaited first!");
26531 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
26532 return nativeResponseValue;
26534 // void InitFeatures_free(struct LDKInitFeatures this_obj);
26536 export function InitFeatures_free(this_obj: number): void {
26537 if(!isWasmInitialized) {
26538 throw new Error("initializeWasm() must be awaited first!");
26540 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
26541 // debug statements here
26543 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
26545 export function NodeFeatures_free(this_obj: number): void {
26546 if(!isWasmInitialized) {
26547 throw new Error("initializeWasm() must be awaited first!");
26549 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
26550 // debug statements here
26552 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
26554 export function ChannelFeatures_free(this_obj: number): void {
26555 if(!isWasmInitialized) {
26556 throw new Error("initializeWasm() must be awaited first!");
26558 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
26559 // debug statements here
26561 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
26563 export function InvoiceFeatures_free(this_obj: number): void {
26564 if(!isWasmInitialized) {
26565 throw new Error("initializeWasm() must be awaited first!");
26567 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
26568 // debug statements here
26570 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
26572 export function ChannelTypeFeatures_free(this_obj: number): void {
26573 if(!isWasmInitialized) {
26574 throw new Error("initializeWasm() must be awaited first!");
26576 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
26577 // debug statements here
26579 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
26581 export function InitFeatures_empty(): number {
26582 if(!isWasmInitialized) {
26583 throw new Error("initializeWasm() must be awaited first!");
26585 const nativeResponseValue = wasm.TS_InitFeatures_empty();
26586 return nativeResponseValue;
26588 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
26590 export function InitFeatures_known(): number {
26591 if(!isWasmInitialized) {
26592 throw new Error("initializeWasm() must be awaited first!");
26594 const nativeResponseValue = wasm.TS_InitFeatures_known();
26595 return nativeResponseValue;
26597 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26599 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
26600 if(!isWasmInitialized) {
26601 throw new Error("initializeWasm() must be awaited first!");
26603 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
26604 return nativeResponseValue;
26606 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
26608 export function NodeFeatures_empty(): number {
26609 if(!isWasmInitialized) {
26610 throw new Error("initializeWasm() must be awaited first!");
26612 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
26613 return nativeResponseValue;
26615 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
26617 export function NodeFeatures_known(): number {
26618 if(!isWasmInitialized) {
26619 throw new Error("initializeWasm() must be awaited first!");
26621 const nativeResponseValue = wasm.TS_NodeFeatures_known();
26622 return nativeResponseValue;
26624 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26626 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
26627 if(!isWasmInitialized) {
26628 throw new Error("initializeWasm() must be awaited first!");
26630 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
26631 return nativeResponseValue;
26633 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
26635 export function ChannelFeatures_empty(): number {
26636 if(!isWasmInitialized) {
26637 throw new Error("initializeWasm() must be awaited first!");
26639 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
26640 return nativeResponseValue;
26642 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
26644 export function ChannelFeatures_known(): number {
26645 if(!isWasmInitialized) {
26646 throw new Error("initializeWasm() must be awaited first!");
26648 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
26649 return nativeResponseValue;
26651 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
26653 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
26654 if(!isWasmInitialized) {
26655 throw new Error("initializeWasm() must be awaited first!");
26657 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
26658 return nativeResponseValue;
26660 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
26662 export function InvoiceFeatures_empty(): number {
26663 if(!isWasmInitialized) {
26664 throw new Error("initializeWasm() must be awaited first!");
26666 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
26667 return nativeResponseValue;
26669 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
26671 export function InvoiceFeatures_known(): number {
26672 if(!isWasmInitialized) {
26673 throw new Error("initializeWasm() must be awaited first!");
26675 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
26676 return nativeResponseValue;
26678 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
26680 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
26681 if(!isWasmInitialized) {
26682 throw new Error("initializeWasm() must be awaited first!");
26684 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
26685 return nativeResponseValue;
26687 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
26689 export function ChannelTypeFeatures_empty(): number {
26690 if(!isWasmInitialized) {
26691 throw new Error("initializeWasm() must be awaited first!");
26693 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
26694 return nativeResponseValue;
26696 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
26698 export function ChannelTypeFeatures_known(): number {
26699 if(!isWasmInitialized) {
26700 throw new Error("initializeWasm() must be awaited first!");
26702 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
26703 return nativeResponseValue;
26705 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
26707 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
26708 if(!isWasmInitialized) {
26709 throw new Error("initializeWasm() must be awaited first!");
26711 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
26712 return nativeResponseValue;
26714 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
26716 export function InitFeatures_write(obj: number): number {
26717 if(!isWasmInitialized) {
26718 throw new Error("initializeWasm() must be awaited first!");
26720 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
26721 return nativeResponseValue;
26723 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
26725 export function InitFeatures_read(ser: number): number {
26726 if(!isWasmInitialized) {
26727 throw new Error("initializeWasm() must be awaited first!");
26729 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
26730 return nativeResponseValue;
26732 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
26734 export function ChannelFeatures_write(obj: number): number {
26735 if(!isWasmInitialized) {
26736 throw new Error("initializeWasm() must be awaited first!");
26738 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
26739 return nativeResponseValue;
26741 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
26743 export function ChannelFeatures_read(ser: number): number {
26744 if(!isWasmInitialized) {
26745 throw new Error("initializeWasm() must be awaited first!");
26747 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
26748 return nativeResponseValue;
26750 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
26752 export function NodeFeatures_write(obj: number): number {
26753 if(!isWasmInitialized) {
26754 throw new Error("initializeWasm() must be awaited first!");
26756 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
26757 return nativeResponseValue;
26759 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
26761 export function NodeFeatures_read(ser: number): number {
26762 if(!isWasmInitialized) {
26763 throw new Error("initializeWasm() must be awaited first!");
26765 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
26766 return nativeResponseValue;
26768 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
26770 export function InvoiceFeatures_write(obj: number): number {
26771 if(!isWasmInitialized) {
26772 throw new Error("initializeWasm() must be awaited first!");
26774 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
26775 return nativeResponseValue;
26777 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
26779 export function InvoiceFeatures_read(ser: number): number {
26780 if(!isWasmInitialized) {
26781 throw new Error("initializeWasm() must be awaited first!");
26783 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
26784 return nativeResponseValue;
26786 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
26788 export function ChannelTypeFeatures_write(obj: number): number {
26789 if(!isWasmInitialized) {
26790 throw new Error("initializeWasm() must be awaited first!");
26792 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
26793 return nativeResponseValue;
26795 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
26797 export function ChannelTypeFeatures_read(ser: number): number {
26798 if(!isWasmInitialized) {
26799 throw new Error("initializeWasm() must be awaited first!");
26801 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
26802 return nativeResponseValue;
26804 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26806 export function InitFeatures_set_data_loss_protect_optional(this_arg: number): void {
26807 if(!isWasmInitialized) {
26808 throw new Error("initializeWasm() must be awaited first!");
26810 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
26811 // debug statements here
26813 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26815 export function InitFeatures_set_data_loss_protect_required(this_arg: number): void {
26816 if(!isWasmInitialized) {
26817 throw new Error("initializeWasm() must be awaited first!");
26819 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
26820 // debug statements here
26822 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26824 export function InitFeatures_supports_data_loss_protect(this_arg: number): boolean {
26825 if(!isWasmInitialized) {
26826 throw new Error("initializeWasm() must be awaited first!");
26828 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
26829 return nativeResponseValue;
26831 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26833 export function NodeFeatures_set_data_loss_protect_optional(this_arg: number): void {
26834 if(!isWasmInitialized) {
26835 throw new Error("initializeWasm() must be awaited first!");
26837 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
26838 // debug statements here
26840 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26842 export function NodeFeatures_set_data_loss_protect_required(this_arg: number): void {
26843 if(!isWasmInitialized) {
26844 throw new Error("initializeWasm() must be awaited first!");
26846 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
26847 // debug statements here
26849 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26851 export function NodeFeatures_supports_data_loss_protect(this_arg: number): boolean {
26852 if(!isWasmInitialized) {
26853 throw new Error("initializeWasm() must be awaited first!");
26855 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
26856 return nativeResponseValue;
26858 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26860 export function InitFeatures_requires_data_loss_protect(this_arg: number): boolean {
26861 if(!isWasmInitialized) {
26862 throw new Error("initializeWasm() must be awaited first!");
26864 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
26865 return nativeResponseValue;
26867 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26869 export function NodeFeatures_requires_data_loss_protect(this_arg: number): boolean {
26870 if(!isWasmInitialized) {
26871 throw new Error("initializeWasm() must be awaited first!");
26873 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
26874 return nativeResponseValue;
26876 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26878 export function InitFeatures_set_initial_routing_sync_optional(this_arg: number): void {
26879 if(!isWasmInitialized) {
26880 throw new Error("initializeWasm() must be awaited first!");
26882 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
26883 // debug statements here
26885 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26887 export function InitFeatures_set_initial_routing_sync_required(this_arg: number): void {
26888 if(!isWasmInitialized) {
26889 throw new Error("initializeWasm() must be awaited first!");
26891 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
26892 // debug statements here
26894 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26896 export function InitFeatures_initial_routing_sync(this_arg: number): boolean {
26897 if(!isWasmInitialized) {
26898 throw new Error("initializeWasm() must be awaited first!");
26900 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
26901 return nativeResponseValue;
26903 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26905 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
26906 if(!isWasmInitialized) {
26907 throw new Error("initializeWasm() must be awaited first!");
26909 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
26910 // debug statements here
26912 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26914 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
26915 if(!isWasmInitialized) {
26916 throw new Error("initializeWasm() must be awaited first!");
26918 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
26919 // debug statements here
26921 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26923 export function InitFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
26924 if(!isWasmInitialized) {
26925 throw new Error("initializeWasm() must be awaited first!");
26927 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
26928 return nativeResponseValue;
26930 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26932 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
26933 if(!isWasmInitialized) {
26934 throw new Error("initializeWasm() must be awaited first!");
26936 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
26937 // debug statements here
26939 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26941 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
26942 if(!isWasmInitialized) {
26943 throw new Error("initializeWasm() must be awaited first!");
26945 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
26946 // debug statements here
26948 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26950 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
26951 if(!isWasmInitialized) {
26952 throw new Error("initializeWasm() must be awaited first!");
26954 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
26955 return nativeResponseValue;
26957 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26959 export function InitFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
26960 if(!isWasmInitialized) {
26961 throw new Error("initializeWasm() must be awaited first!");
26963 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
26964 return nativeResponseValue;
26966 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26968 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
26969 if(!isWasmInitialized) {
26970 throw new Error("initializeWasm() must be awaited first!");
26972 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
26973 return nativeResponseValue;
26975 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26977 export function InitFeatures_set_gossip_queries_optional(this_arg: number): void {
26978 if(!isWasmInitialized) {
26979 throw new Error("initializeWasm() must be awaited first!");
26981 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
26982 // debug statements here
26984 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26986 export function InitFeatures_set_gossip_queries_required(this_arg: number): void {
26987 if(!isWasmInitialized) {
26988 throw new Error("initializeWasm() must be awaited first!");
26990 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
26991 // debug statements here
26993 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26995 export function InitFeatures_supports_gossip_queries(this_arg: number): boolean {
26996 if(!isWasmInitialized) {
26997 throw new Error("initializeWasm() must be awaited first!");
26999 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
27000 return nativeResponseValue;
27002 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27004 export function NodeFeatures_set_gossip_queries_optional(this_arg: number): void {
27005 if(!isWasmInitialized) {
27006 throw new Error("initializeWasm() must be awaited first!");
27008 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27009 // debug statements here
27011 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27013 export function NodeFeatures_set_gossip_queries_required(this_arg: number): void {
27014 if(!isWasmInitialized) {
27015 throw new Error("initializeWasm() must be awaited first!");
27017 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27018 // debug statements here
27020 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27022 export function NodeFeatures_supports_gossip_queries(this_arg: number): boolean {
27023 if(!isWasmInitialized) {
27024 throw new Error("initializeWasm() must be awaited first!");
27026 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27027 return nativeResponseValue;
27029 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27031 export function InitFeatures_requires_gossip_queries(this_arg: number): boolean {
27032 if(!isWasmInitialized) {
27033 throw new Error("initializeWasm() must be awaited first!");
27035 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27036 return nativeResponseValue;
27038 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27040 export function NodeFeatures_requires_gossip_queries(this_arg: number): boolean {
27041 if(!isWasmInitialized) {
27042 throw new Error("initializeWasm() must be awaited first!");
27044 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27045 return nativeResponseValue;
27047 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27049 export function InitFeatures_set_variable_length_onion_optional(this_arg: number): void {
27050 if(!isWasmInitialized) {
27051 throw new Error("initializeWasm() must be awaited first!");
27053 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27054 // debug statements here
27056 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27058 export function InitFeatures_set_variable_length_onion_required(this_arg: number): void {
27059 if(!isWasmInitialized) {
27060 throw new Error("initializeWasm() must be awaited first!");
27062 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27063 // debug statements here
27065 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27067 export function InitFeatures_supports_variable_length_onion(this_arg: number): boolean {
27068 if(!isWasmInitialized) {
27069 throw new Error("initializeWasm() must be awaited first!");
27071 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27072 return nativeResponseValue;
27074 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27076 export function NodeFeatures_set_variable_length_onion_optional(this_arg: number): void {
27077 if(!isWasmInitialized) {
27078 throw new Error("initializeWasm() must be awaited first!");
27080 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27081 // debug statements here
27083 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27085 export function NodeFeatures_set_variable_length_onion_required(this_arg: number): void {
27086 if(!isWasmInitialized) {
27087 throw new Error("initializeWasm() must be awaited first!");
27089 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27090 // debug statements here
27092 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27094 export function NodeFeatures_supports_variable_length_onion(this_arg: number): boolean {
27095 if(!isWasmInitialized) {
27096 throw new Error("initializeWasm() must be awaited first!");
27098 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27099 return nativeResponseValue;
27101 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27103 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: number): void {
27104 if(!isWasmInitialized) {
27105 throw new Error("initializeWasm() must be awaited first!");
27107 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27108 // debug statements here
27110 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27112 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: number): void {
27113 if(!isWasmInitialized) {
27114 throw new Error("initializeWasm() must be awaited first!");
27116 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27117 // debug statements here
27119 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27121 export function InvoiceFeatures_supports_variable_length_onion(this_arg: number): boolean {
27122 if(!isWasmInitialized) {
27123 throw new Error("initializeWasm() must be awaited first!");
27125 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
27126 return nativeResponseValue;
27128 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27130 export function InitFeatures_requires_variable_length_onion(this_arg: number): boolean {
27131 if(!isWasmInitialized) {
27132 throw new Error("initializeWasm() must be awaited first!");
27134 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
27135 return nativeResponseValue;
27137 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27139 export function NodeFeatures_requires_variable_length_onion(this_arg: number): boolean {
27140 if(!isWasmInitialized) {
27141 throw new Error("initializeWasm() must be awaited first!");
27143 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
27144 return nativeResponseValue;
27146 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27148 export function InvoiceFeatures_requires_variable_length_onion(this_arg: number): boolean {
27149 if(!isWasmInitialized) {
27150 throw new Error("initializeWasm() must be awaited first!");
27152 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
27153 return nativeResponseValue;
27155 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27157 export function InitFeatures_set_static_remote_key_optional(this_arg: number): void {
27158 if(!isWasmInitialized) {
27159 throw new Error("initializeWasm() must be awaited first!");
27161 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
27162 // debug statements here
27164 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27166 export function InitFeatures_set_static_remote_key_required(this_arg: number): void {
27167 if(!isWasmInitialized) {
27168 throw new Error("initializeWasm() must be awaited first!");
27170 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
27171 // debug statements here
27173 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27175 export function InitFeatures_supports_static_remote_key(this_arg: number): boolean {
27176 if(!isWasmInitialized) {
27177 throw new Error("initializeWasm() must be awaited first!");
27179 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
27180 return nativeResponseValue;
27182 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27184 export function NodeFeatures_set_static_remote_key_optional(this_arg: number): void {
27185 if(!isWasmInitialized) {
27186 throw new Error("initializeWasm() must be awaited first!");
27188 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
27189 // debug statements here
27191 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27193 export function NodeFeatures_set_static_remote_key_required(this_arg: number): void {
27194 if(!isWasmInitialized) {
27195 throw new Error("initializeWasm() must be awaited first!");
27197 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
27198 // debug statements here
27200 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27202 export function NodeFeatures_supports_static_remote_key(this_arg: number): boolean {
27203 if(!isWasmInitialized) {
27204 throw new Error("initializeWasm() must be awaited first!");
27206 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
27207 return nativeResponseValue;
27209 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27211 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: number): void {
27212 if(!isWasmInitialized) {
27213 throw new Error("initializeWasm() must be awaited first!");
27215 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
27216 // debug statements here
27218 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27220 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: number): void {
27221 if(!isWasmInitialized) {
27222 throw new Error("initializeWasm() must be awaited first!");
27224 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
27225 // debug statements here
27227 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27229 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: number): boolean {
27230 if(!isWasmInitialized) {
27231 throw new Error("initializeWasm() must be awaited first!");
27233 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
27234 return nativeResponseValue;
27236 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27238 export function InitFeatures_requires_static_remote_key(this_arg: number): boolean {
27239 if(!isWasmInitialized) {
27240 throw new Error("initializeWasm() must be awaited first!");
27242 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
27243 return nativeResponseValue;
27245 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27247 export function NodeFeatures_requires_static_remote_key(this_arg: number): boolean {
27248 if(!isWasmInitialized) {
27249 throw new Error("initializeWasm() must be awaited first!");
27251 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
27252 return nativeResponseValue;
27254 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27256 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: number): boolean {
27257 if(!isWasmInitialized) {
27258 throw new Error("initializeWasm() must be awaited first!");
27260 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
27261 return nativeResponseValue;
27263 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27265 export function InitFeatures_set_payment_secret_optional(this_arg: number): void {
27266 if(!isWasmInitialized) {
27267 throw new Error("initializeWasm() must be awaited first!");
27269 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
27270 // debug statements here
27272 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27274 export function InitFeatures_set_payment_secret_required(this_arg: number): void {
27275 if(!isWasmInitialized) {
27276 throw new Error("initializeWasm() must be awaited first!");
27278 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
27279 // debug statements here
27281 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27283 export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
27284 if(!isWasmInitialized) {
27285 throw new Error("initializeWasm() must be awaited first!");
27287 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
27288 return nativeResponseValue;
27290 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27292 export function NodeFeatures_set_payment_secret_optional(this_arg: number): void {
27293 if(!isWasmInitialized) {
27294 throw new Error("initializeWasm() must be awaited first!");
27296 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
27297 // debug statements here
27299 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27301 export function NodeFeatures_set_payment_secret_required(this_arg: number): void {
27302 if(!isWasmInitialized) {
27303 throw new Error("initializeWasm() must be awaited first!");
27305 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
27306 // debug statements here
27308 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27310 export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
27311 if(!isWasmInitialized) {
27312 throw new Error("initializeWasm() must be awaited first!");
27314 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
27315 return nativeResponseValue;
27317 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27319 export function InvoiceFeatures_set_payment_secret_optional(this_arg: number): void {
27320 if(!isWasmInitialized) {
27321 throw new Error("initializeWasm() must be awaited first!");
27323 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
27324 // debug statements here
27326 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27328 export function InvoiceFeatures_set_payment_secret_required(this_arg: number): void {
27329 if(!isWasmInitialized) {
27330 throw new Error("initializeWasm() must be awaited first!");
27332 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
27333 // debug statements here
27335 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27337 export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
27338 if(!isWasmInitialized) {
27339 throw new Error("initializeWasm() must be awaited first!");
27341 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
27342 return nativeResponseValue;
27344 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27346 export function InitFeatures_requires_payment_secret(this_arg: number): boolean {
27347 if(!isWasmInitialized) {
27348 throw new Error("initializeWasm() must be awaited first!");
27350 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
27351 return nativeResponseValue;
27353 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27355 export function NodeFeatures_requires_payment_secret(this_arg: number): boolean {
27356 if(!isWasmInitialized) {
27357 throw new Error("initializeWasm() must be awaited first!");
27359 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
27360 return nativeResponseValue;
27362 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27364 export function InvoiceFeatures_requires_payment_secret(this_arg: number): boolean {
27365 if(!isWasmInitialized) {
27366 throw new Error("initializeWasm() must be awaited first!");
27368 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
27369 return nativeResponseValue;
27371 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27373 export function InitFeatures_set_basic_mpp_optional(this_arg: number): void {
27374 if(!isWasmInitialized) {
27375 throw new Error("initializeWasm() must be awaited first!");
27377 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
27378 // debug statements here
27380 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27382 export function InitFeatures_set_basic_mpp_required(this_arg: number): void {
27383 if(!isWasmInitialized) {
27384 throw new Error("initializeWasm() must be awaited first!");
27386 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
27387 // debug statements here
27389 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27391 export function InitFeatures_supports_basic_mpp(this_arg: number): boolean {
27392 if(!isWasmInitialized) {
27393 throw new Error("initializeWasm() must be awaited first!");
27395 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
27396 return nativeResponseValue;
27398 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27400 export function NodeFeatures_set_basic_mpp_optional(this_arg: number): void {
27401 if(!isWasmInitialized) {
27402 throw new Error("initializeWasm() must be awaited first!");
27404 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
27405 // debug statements here
27407 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27409 export function NodeFeatures_set_basic_mpp_required(this_arg: number): void {
27410 if(!isWasmInitialized) {
27411 throw new Error("initializeWasm() must be awaited first!");
27413 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
27414 // debug statements here
27416 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27418 export function NodeFeatures_supports_basic_mpp(this_arg: number): boolean {
27419 if(!isWasmInitialized) {
27420 throw new Error("initializeWasm() must be awaited first!");
27422 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
27423 return nativeResponseValue;
27425 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27427 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: number): void {
27428 if(!isWasmInitialized) {
27429 throw new Error("initializeWasm() must be awaited first!");
27431 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
27432 // debug statements here
27434 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27436 export function InvoiceFeatures_set_basic_mpp_required(this_arg: number): void {
27437 if(!isWasmInitialized) {
27438 throw new Error("initializeWasm() must be awaited first!");
27440 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
27441 // debug statements here
27443 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27445 export function InvoiceFeatures_supports_basic_mpp(this_arg: number): boolean {
27446 if(!isWasmInitialized) {
27447 throw new Error("initializeWasm() must be awaited first!");
27449 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
27450 return nativeResponseValue;
27452 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27454 export function InitFeatures_requires_basic_mpp(this_arg: number): boolean {
27455 if(!isWasmInitialized) {
27456 throw new Error("initializeWasm() must be awaited first!");
27458 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
27459 return nativeResponseValue;
27461 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27463 export function NodeFeatures_requires_basic_mpp(this_arg: number): boolean {
27464 if(!isWasmInitialized) {
27465 throw new Error("initializeWasm() must be awaited first!");
27467 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
27468 return nativeResponseValue;
27470 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27472 export function InvoiceFeatures_requires_basic_mpp(this_arg: number): boolean {
27473 if(!isWasmInitialized) {
27474 throw new Error("initializeWasm() must be awaited first!");
27476 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
27477 return nativeResponseValue;
27479 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27481 export function InitFeatures_set_wumbo_optional(this_arg: number): void {
27482 if(!isWasmInitialized) {
27483 throw new Error("initializeWasm() must be awaited first!");
27485 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
27486 // debug statements here
27488 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27490 export function InitFeatures_set_wumbo_required(this_arg: number): void {
27491 if(!isWasmInitialized) {
27492 throw new Error("initializeWasm() must be awaited first!");
27494 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
27495 // debug statements here
27497 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27499 export function InitFeatures_supports_wumbo(this_arg: number): boolean {
27500 if(!isWasmInitialized) {
27501 throw new Error("initializeWasm() must be awaited first!");
27503 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
27504 return nativeResponseValue;
27506 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27508 export function NodeFeatures_set_wumbo_optional(this_arg: number): void {
27509 if(!isWasmInitialized) {
27510 throw new Error("initializeWasm() must be awaited first!");
27512 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
27513 // debug statements here
27515 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27517 export function NodeFeatures_set_wumbo_required(this_arg: number): void {
27518 if(!isWasmInitialized) {
27519 throw new Error("initializeWasm() must be awaited first!");
27521 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
27522 // debug statements here
27524 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27526 export function NodeFeatures_supports_wumbo(this_arg: number): boolean {
27527 if(!isWasmInitialized) {
27528 throw new Error("initializeWasm() must be awaited first!");
27530 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
27531 return nativeResponseValue;
27533 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27535 export function InitFeatures_requires_wumbo(this_arg: number): boolean {
27536 if(!isWasmInitialized) {
27537 throw new Error("initializeWasm() must be awaited first!");
27539 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
27540 return nativeResponseValue;
27542 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27544 export function NodeFeatures_requires_wumbo(this_arg: number): boolean {
27545 if(!isWasmInitialized) {
27546 throw new Error("initializeWasm() must be awaited first!");
27548 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
27549 return nativeResponseValue;
27551 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27553 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27554 if(!isWasmInitialized) {
27555 throw new Error("initializeWasm() must be awaited first!");
27557 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
27558 // debug statements here
27560 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27562 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27563 if(!isWasmInitialized) {
27564 throw new Error("initializeWasm() must be awaited first!");
27566 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
27567 // debug statements here
27569 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27571 export function InitFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27572 if(!isWasmInitialized) {
27573 throw new Error("initializeWasm() must be awaited first!");
27575 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
27576 return nativeResponseValue;
27578 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27580 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27581 if(!isWasmInitialized) {
27582 throw new Error("initializeWasm() must be awaited first!");
27584 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
27585 // debug statements here
27587 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27589 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27590 if(!isWasmInitialized) {
27591 throw new Error("initializeWasm() must be awaited first!");
27593 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
27594 // debug statements here
27596 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27598 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27599 if(!isWasmInitialized) {
27600 throw new Error("initializeWasm() must be awaited first!");
27602 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
27603 return nativeResponseValue;
27605 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27607 export function InitFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27608 if(!isWasmInitialized) {
27609 throw new Error("initializeWasm() must be awaited first!");
27611 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
27612 return nativeResponseValue;
27614 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27616 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27617 if(!isWasmInitialized) {
27618 throw new Error("initializeWasm() must be awaited first!");
27620 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
27621 return nativeResponseValue;
27623 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27625 export function InitFeatures_set_channel_type_optional(this_arg: number): void {
27626 if(!isWasmInitialized) {
27627 throw new Error("initializeWasm() must be awaited first!");
27629 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
27630 // debug statements here
27632 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27634 export function InitFeatures_set_channel_type_required(this_arg: number): void {
27635 if(!isWasmInitialized) {
27636 throw new Error("initializeWasm() must be awaited first!");
27638 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
27639 // debug statements here
27641 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27643 export function InitFeatures_supports_channel_type(this_arg: number): boolean {
27644 if(!isWasmInitialized) {
27645 throw new Error("initializeWasm() must be awaited first!");
27647 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
27648 return nativeResponseValue;
27650 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27652 export function NodeFeatures_set_channel_type_optional(this_arg: number): void {
27653 if(!isWasmInitialized) {
27654 throw new Error("initializeWasm() must be awaited first!");
27656 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
27657 // debug statements here
27659 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27661 export function NodeFeatures_set_channel_type_required(this_arg: number): void {
27662 if(!isWasmInitialized) {
27663 throw new Error("initializeWasm() must be awaited first!");
27665 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
27666 // debug statements here
27668 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27670 export function NodeFeatures_supports_channel_type(this_arg: number): boolean {
27671 if(!isWasmInitialized) {
27672 throw new Error("initializeWasm() must be awaited first!");
27674 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
27675 return nativeResponseValue;
27677 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27679 export function InitFeatures_requires_channel_type(this_arg: number): boolean {
27680 if(!isWasmInitialized) {
27681 throw new Error("initializeWasm() must be awaited first!");
27683 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
27684 return nativeResponseValue;
27686 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27688 export function NodeFeatures_requires_channel_type(this_arg: number): boolean {
27689 if(!isWasmInitialized) {
27690 throw new Error("initializeWasm() must be awaited first!");
27692 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
27693 return nativeResponseValue;
27695 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27697 export function InitFeatures_set_scid_privacy_optional(this_arg: number): void {
27698 if(!isWasmInitialized) {
27699 throw new Error("initializeWasm() must be awaited first!");
27701 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
27702 // debug statements here
27704 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27706 export function InitFeatures_set_scid_privacy_required(this_arg: number): void {
27707 if(!isWasmInitialized) {
27708 throw new Error("initializeWasm() must be awaited first!");
27710 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
27711 // debug statements here
27713 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27715 export function InitFeatures_supports_scid_privacy(this_arg: number): boolean {
27716 if(!isWasmInitialized) {
27717 throw new Error("initializeWasm() must be awaited first!");
27719 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
27720 return nativeResponseValue;
27722 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27724 export function NodeFeatures_set_scid_privacy_optional(this_arg: number): void {
27725 if(!isWasmInitialized) {
27726 throw new Error("initializeWasm() must be awaited first!");
27728 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
27729 // debug statements here
27731 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27733 export function NodeFeatures_set_scid_privacy_required(this_arg: number): void {
27734 if(!isWasmInitialized) {
27735 throw new Error("initializeWasm() must be awaited first!");
27737 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
27738 // debug statements here
27740 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27742 export function NodeFeatures_supports_scid_privacy(this_arg: number): boolean {
27743 if(!isWasmInitialized) {
27744 throw new Error("initializeWasm() must be awaited first!");
27746 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
27747 return nativeResponseValue;
27749 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27751 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: number): void {
27752 if(!isWasmInitialized) {
27753 throw new Error("initializeWasm() must be awaited first!");
27755 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
27756 // debug statements here
27758 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27760 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: number): void {
27761 if(!isWasmInitialized) {
27762 throw new Error("initializeWasm() must be awaited first!");
27764 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
27765 // debug statements here
27767 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27769 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: number): boolean {
27770 if(!isWasmInitialized) {
27771 throw new Error("initializeWasm() must be awaited first!");
27773 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
27774 return nativeResponseValue;
27776 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27778 export function InitFeatures_requires_scid_privacy(this_arg: number): boolean {
27779 if(!isWasmInitialized) {
27780 throw new Error("initializeWasm() must be awaited first!");
27782 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
27783 return nativeResponseValue;
27785 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27787 export function NodeFeatures_requires_scid_privacy(this_arg: number): boolean {
27788 if(!isWasmInitialized) {
27789 throw new Error("initializeWasm() must be awaited first!");
27791 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
27792 return nativeResponseValue;
27794 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27796 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: number): boolean {
27797 if(!isWasmInitialized) {
27798 throw new Error("initializeWasm() must be awaited first!");
27800 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
27801 return nativeResponseValue;
27803 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27805 export function InitFeatures_set_zero_conf_optional(this_arg: number): void {
27806 if(!isWasmInitialized) {
27807 throw new Error("initializeWasm() must be awaited first!");
27809 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
27810 // debug statements here
27812 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27814 export function InitFeatures_set_zero_conf_required(this_arg: number): void {
27815 if(!isWasmInitialized) {
27816 throw new Error("initializeWasm() must be awaited first!");
27818 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
27819 // debug statements here
27821 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27823 export function InitFeatures_supports_zero_conf(this_arg: number): boolean {
27824 if(!isWasmInitialized) {
27825 throw new Error("initializeWasm() must be awaited first!");
27827 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
27828 return nativeResponseValue;
27830 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27832 export function NodeFeatures_set_zero_conf_optional(this_arg: number): void {
27833 if(!isWasmInitialized) {
27834 throw new Error("initializeWasm() must be awaited first!");
27836 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
27837 // debug statements here
27839 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27841 export function NodeFeatures_set_zero_conf_required(this_arg: number): void {
27842 if(!isWasmInitialized) {
27843 throw new Error("initializeWasm() must be awaited first!");
27845 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
27846 // debug statements here
27848 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27850 export function NodeFeatures_supports_zero_conf(this_arg: number): boolean {
27851 if(!isWasmInitialized) {
27852 throw new Error("initializeWasm() must be awaited first!");
27854 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
27855 return nativeResponseValue;
27857 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27859 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: number): void {
27860 if(!isWasmInitialized) {
27861 throw new Error("initializeWasm() must be awaited first!");
27863 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
27864 // debug statements here
27866 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27868 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: number): void {
27869 if(!isWasmInitialized) {
27870 throw new Error("initializeWasm() must be awaited first!");
27872 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
27873 // debug statements here
27875 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27877 export function ChannelTypeFeatures_supports_zero_conf(this_arg: number): boolean {
27878 if(!isWasmInitialized) {
27879 throw new Error("initializeWasm() must be awaited first!");
27881 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
27882 return nativeResponseValue;
27884 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27886 export function InitFeatures_requires_zero_conf(this_arg: number): boolean {
27887 if(!isWasmInitialized) {
27888 throw new Error("initializeWasm() must be awaited first!");
27890 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
27891 return nativeResponseValue;
27893 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27895 export function NodeFeatures_requires_zero_conf(this_arg: number): boolean {
27896 if(!isWasmInitialized) {
27897 throw new Error("initializeWasm() must be awaited first!");
27899 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
27900 return nativeResponseValue;
27902 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27904 export function ChannelTypeFeatures_requires_zero_conf(this_arg: number): boolean {
27905 if(!isWasmInitialized) {
27906 throw new Error("initializeWasm() must be awaited first!");
27908 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
27909 return nativeResponseValue;
27911 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27913 export function NodeFeatures_set_keysend_optional(this_arg: number): void {
27914 if(!isWasmInitialized) {
27915 throw new Error("initializeWasm() must be awaited first!");
27917 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
27918 // debug statements here
27920 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27922 export function NodeFeatures_set_keysend_required(this_arg: number): void {
27923 if(!isWasmInitialized) {
27924 throw new Error("initializeWasm() must be awaited first!");
27926 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
27927 // debug statements here
27929 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27931 export function NodeFeatures_supports_keysend(this_arg: number): boolean {
27932 if(!isWasmInitialized) {
27933 throw new Error("initializeWasm() must be awaited first!");
27935 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
27936 return nativeResponseValue;
27938 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27940 export function NodeFeatures_requires_keysend(this_arg: number): boolean {
27941 if(!isWasmInitialized) {
27942 throw new Error("initializeWasm() must be awaited first!");
27944 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
27945 return nativeResponseValue;
27947 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
27949 export function ShutdownScript_free(this_obj: number): void {
27950 if(!isWasmInitialized) {
27951 throw new Error("initializeWasm() must be awaited first!");
27953 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
27954 // debug statements here
27956 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
27958 export function ShutdownScript_clone_ptr(arg: number): number {
27959 if(!isWasmInitialized) {
27960 throw new Error("initializeWasm() must be awaited first!");
27962 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
27963 return nativeResponseValue;
27965 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
27967 export function ShutdownScript_clone(orig: number): number {
27968 if(!isWasmInitialized) {
27969 throw new Error("initializeWasm() must be awaited first!");
27971 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
27972 return nativeResponseValue;
27974 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
27976 export function InvalidShutdownScript_free(this_obj: number): void {
27977 if(!isWasmInitialized) {
27978 throw new Error("initializeWasm() must be awaited first!");
27980 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
27981 // debug statements here
27983 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
27985 export function InvalidShutdownScript_get_script(this_ptr: number): number {
27986 if(!isWasmInitialized) {
27987 throw new Error("initializeWasm() must be awaited first!");
27989 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
27990 return nativeResponseValue;
27992 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
27994 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
27995 if(!isWasmInitialized) {
27996 throw new Error("initializeWasm() must be awaited first!");
27998 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
27999 // debug statements here
28001 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28003 export function InvalidShutdownScript_new(script_arg: number): number {
28004 if(!isWasmInitialized) {
28005 throw new Error("initializeWasm() must be awaited first!");
28007 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28008 return nativeResponseValue;
28010 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28012 export function InvalidShutdownScript_clone_ptr(arg: number): number {
28013 if(!isWasmInitialized) {
28014 throw new Error("initializeWasm() must be awaited first!");
28016 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28017 return nativeResponseValue;
28019 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28021 export function InvalidShutdownScript_clone(orig: number): number {
28022 if(!isWasmInitialized) {
28023 throw new Error("initializeWasm() must be awaited first!");
28025 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28026 return nativeResponseValue;
28028 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28030 export function ShutdownScript_write(obj: number): number {
28031 if(!isWasmInitialized) {
28032 throw new Error("initializeWasm() must be awaited first!");
28034 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28035 return nativeResponseValue;
28037 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28039 export function ShutdownScript_read(ser: number): number {
28040 if(!isWasmInitialized) {
28041 throw new Error("initializeWasm() must be awaited first!");
28043 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28044 return nativeResponseValue;
28046 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28048 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
28049 if(!isWasmInitialized) {
28050 throw new Error("initializeWasm() must be awaited first!");
28052 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28053 return nativeResponseValue;
28055 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28057 export function ShutdownScript_new_p2wsh(script_hash: number): number {
28058 if(!isWasmInitialized) {
28059 throw new Error("initializeWasm() must be awaited first!");
28061 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28062 return nativeResponseValue;
28064 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28066 export function ShutdownScript_new_witness_program(version: number, program: number): number {
28067 if(!isWasmInitialized) {
28068 throw new Error("initializeWasm() must be awaited first!");
28070 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28071 return nativeResponseValue;
28073 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28075 export function ShutdownScript_into_inner(this_arg: number): number {
28076 if(!isWasmInitialized) {
28077 throw new Error("initializeWasm() must be awaited first!");
28079 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28080 return nativeResponseValue;
28082 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28084 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
28085 if(!isWasmInitialized) {
28086 throw new Error("initializeWasm() must be awaited first!");
28088 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28089 return nativeResponseValue;
28091 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28093 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
28094 if(!isWasmInitialized) {
28095 throw new Error("initializeWasm() must be awaited first!");
28097 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28098 return nativeResponseValue;
28100 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28102 export function CustomMessageReader_free(this_ptr: number): void {
28103 if(!isWasmInitialized) {
28104 throw new Error("initializeWasm() must be awaited first!");
28106 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28107 // debug statements here
28109 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28111 export function Type_clone_ptr(arg: number): number {
28112 if(!isWasmInitialized) {
28113 throw new Error("initializeWasm() must be awaited first!");
28115 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28116 return nativeResponseValue;
28118 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28120 export function Type_clone(orig: number): number {
28121 if(!isWasmInitialized) {
28122 throw new Error("initializeWasm() must be awaited first!");
28124 const nativeResponseValue = wasm.TS_Type_clone(orig);
28125 return nativeResponseValue;
28127 // void Type_free(struct LDKType this_ptr);
28129 export function Type_free(this_ptr: number): void {
28130 if(!isWasmInitialized) {
28131 throw new Error("initializeWasm() must be awaited first!");
28133 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
28134 // debug statements here
28136 // void NodeId_free(struct LDKNodeId this_obj);
28138 export function NodeId_free(this_obj: number): void {
28139 if(!isWasmInitialized) {
28140 throw new Error("initializeWasm() must be awaited first!");
28142 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
28143 // debug statements here
28145 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
28147 export function NodeId_clone_ptr(arg: number): number {
28148 if(!isWasmInitialized) {
28149 throw new Error("initializeWasm() must be awaited first!");
28151 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
28152 return nativeResponseValue;
28154 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
28156 export function NodeId_clone(orig: number): number {
28157 if(!isWasmInitialized) {
28158 throw new Error("initializeWasm() must be awaited first!");
28160 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
28161 return nativeResponseValue;
28163 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
28165 export function NodeId_from_pubkey(pubkey: number): number {
28166 if(!isWasmInitialized) {
28167 throw new Error("initializeWasm() must be awaited first!");
28169 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
28170 return nativeResponseValue;
28172 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
28174 export function NodeId_as_slice(this_arg: number): number {
28175 if(!isWasmInitialized) {
28176 throw new Error("initializeWasm() must be awaited first!");
28178 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
28179 return nativeResponseValue;
28181 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
28183 export function NodeId_hash(o: number): bigint {
28184 if(!isWasmInitialized) {
28185 throw new Error("initializeWasm() must be awaited first!");
28187 const nativeResponseValue = wasm.TS_NodeId_hash(o);
28188 return nativeResponseValue;
28190 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
28192 export function NodeId_write(obj: number): number {
28193 if(!isWasmInitialized) {
28194 throw new Error("initializeWasm() must be awaited first!");
28196 const nativeResponseValue = wasm.TS_NodeId_write(obj);
28197 return nativeResponseValue;
28199 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
28201 export function NodeId_read(ser: number): number {
28202 if(!isWasmInitialized) {
28203 throw new Error("initializeWasm() must be awaited first!");
28205 const nativeResponseValue = wasm.TS_NodeId_read(ser);
28206 return nativeResponseValue;
28208 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
28210 export function NetworkGraph_free(this_obj: number): void {
28211 if(!isWasmInitialized) {
28212 throw new Error("initializeWasm() must be awaited first!");
28214 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
28215 // debug statements here
28217 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
28219 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
28220 if(!isWasmInitialized) {
28221 throw new Error("initializeWasm() must be awaited first!");
28223 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
28224 // debug statements here
28226 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
28228 export function NetworkUpdate_free(this_ptr: number): void {
28229 if(!isWasmInitialized) {
28230 throw new Error("initializeWasm() must be awaited first!");
28232 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
28233 // debug statements here
28235 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
28237 export function NetworkUpdate_clone_ptr(arg: number): number {
28238 if(!isWasmInitialized) {
28239 throw new Error("initializeWasm() must be awaited first!");
28241 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
28242 return nativeResponseValue;
28244 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
28246 export function NetworkUpdate_clone(orig: number): number {
28247 if(!isWasmInitialized) {
28248 throw new Error("initializeWasm() must be awaited first!");
28250 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
28251 return nativeResponseValue;
28253 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
28255 export function NetworkUpdate_channel_update_message(msg: number): number {
28256 if(!isWasmInitialized) {
28257 throw new Error("initializeWasm() must be awaited first!");
28259 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
28260 return nativeResponseValue;
28262 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
28264 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): number {
28265 if(!isWasmInitialized) {
28266 throw new Error("initializeWasm() must be awaited first!");
28268 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
28269 return nativeResponseValue;
28271 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
28273 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
28274 if(!isWasmInitialized) {
28275 throw new Error("initializeWasm() must be awaited first!");
28277 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
28278 return nativeResponseValue;
28280 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
28282 export function NetworkUpdate_write(obj: number): number {
28283 if(!isWasmInitialized) {
28284 throw new Error("initializeWasm() must be awaited first!");
28286 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
28287 return nativeResponseValue;
28289 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
28291 export function NetworkUpdate_read(ser: number): number {
28292 if(!isWasmInitialized) {
28293 throw new Error("initializeWasm() must be awaited first!");
28295 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
28296 return nativeResponseValue;
28298 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
28300 export function P2PGossipSync_free(this_obj: number): void {
28301 if(!isWasmInitialized) {
28302 throw new Error("initializeWasm() must be awaited first!");
28304 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
28305 // debug statements here
28307 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
28309 export function P2PGossipSync_new(network_graph: number, chain_access: number, logger: number): number {
28310 if(!isWasmInitialized) {
28311 throw new Error("initializeWasm() must be awaited first!");
28313 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
28314 return nativeResponseValue;
28316 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
28318 export function P2PGossipSync_add_chain_access(this_arg: number, chain_access: number): void {
28319 if(!isWasmInitialized) {
28320 throw new Error("initializeWasm() must be awaited first!");
28322 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
28323 // debug statements here
28325 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
28327 export function NetworkGraph_as_EventHandler(this_arg: number): number {
28328 if(!isWasmInitialized) {
28329 throw new Error("initializeWasm() must be awaited first!");
28331 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
28332 return nativeResponseValue;
28334 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28336 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: number): number {
28337 if(!isWasmInitialized) {
28338 throw new Error("initializeWasm() must be awaited first!");
28340 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
28341 return nativeResponseValue;
28343 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28345 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: number): number {
28346 if(!isWasmInitialized) {
28347 throw new Error("initializeWasm() must be awaited first!");
28349 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
28350 return nativeResponseValue;
28352 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
28354 export function ChannelUpdateInfo_free(this_obj: number): void {
28355 if(!isWasmInitialized) {
28356 throw new Error("initializeWasm() must be awaited first!");
28358 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
28359 // debug statements here
28361 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28363 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
28364 if(!isWasmInitialized) {
28365 throw new Error("initializeWasm() must be awaited first!");
28367 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
28368 return nativeResponseValue;
28370 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
28372 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
28373 if(!isWasmInitialized) {
28374 throw new Error("initializeWasm() must be awaited first!");
28376 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
28377 // debug statements here
28379 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28381 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
28382 if(!isWasmInitialized) {
28383 throw new Error("initializeWasm() must be awaited first!");
28385 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
28386 return nativeResponseValue;
28388 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
28390 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
28391 if(!isWasmInitialized) {
28392 throw new Error("initializeWasm() must be awaited first!");
28394 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
28395 // debug statements here
28397 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28399 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
28400 if(!isWasmInitialized) {
28401 throw new Error("initializeWasm() must be awaited first!");
28403 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
28404 return nativeResponseValue;
28406 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
28408 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28409 if(!isWasmInitialized) {
28410 throw new Error("initializeWasm() must be awaited first!");
28412 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
28413 // debug statements here
28415 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28417 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
28418 if(!isWasmInitialized) {
28419 throw new Error("initializeWasm() must be awaited first!");
28421 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
28422 return nativeResponseValue;
28424 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
28426 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
28427 if(!isWasmInitialized) {
28428 throw new Error("initializeWasm() must be awaited first!");
28430 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
28431 // debug statements here
28433 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28435 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
28436 if(!isWasmInitialized) {
28437 throw new Error("initializeWasm() must be awaited first!");
28439 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
28440 return nativeResponseValue;
28442 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28444 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28445 if(!isWasmInitialized) {
28446 throw new Error("initializeWasm() must be awaited first!");
28448 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
28449 // debug statements here
28451 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28453 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
28454 if(!isWasmInitialized) {
28455 throw new Error("initializeWasm() must be awaited first!");
28457 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
28458 return nativeResponseValue;
28460 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
28462 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
28463 if(!isWasmInitialized) {
28464 throw new Error("initializeWasm() must be awaited first!");
28466 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
28467 // debug statements here
28469 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28471 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
28472 if(!isWasmInitialized) {
28473 throw new Error("initializeWasm() must be awaited first!");
28475 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
28476 return nativeResponseValue;
28478 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
28480 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
28481 if(!isWasmInitialized) {
28482 throw new Error("initializeWasm() must be awaited first!");
28484 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
28485 // debug statements here
28487 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_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);
28489 export function ChannelUpdateInfo_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 {
28490 if(!isWasmInitialized) {
28491 throw new Error("initializeWasm() must be awaited first!");
28493 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_message_arg);
28494 return nativeResponseValue;
28496 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
28498 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
28499 if(!isWasmInitialized) {
28500 throw new Error("initializeWasm() must be awaited first!");
28502 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
28503 return nativeResponseValue;
28505 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
28507 export function ChannelUpdateInfo_clone(orig: number): number {
28508 if(!isWasmInitialized) {
28509 throw new Error("initializeWasm() must be awaited first!");
28511 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
28512 return nativeResponseValue;
28514 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
28516 export function ChannelUpdateInfo_write(obj: number): number {
28517 if(!isWasmInitialized) {
28518 throw new Error("initializeWasm() must be awaited first!");
28520 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
28521 return nativeResponseValue;
28523 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
28525 export function ChannelUpdateInfo_read(ser: number): number {
28526 if(!isWasmInitialized) {
28527 throw new Error("initializeWasm() must be awaited first!");
28529 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
28530 return nativeResponseValue;
28532 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
28534 export function ChannelInfo_free(this_obj: number): void {
28535 if(!isWasmInitialized) {
28536 throw new Error("initializeWasm() must be awaited first!");
28538 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
28539 // debug statements here
28541 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28543 export function ChannelInfo_get_features(this_ptr: number): number {
28544 if(!isWasmInitialized) {
28545 throw new Error("initializeWasm() must be awaited first!");
28547 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
28548 return nativeResponseValue;
28550 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
28552 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
28553 if(!isWasmInitialized) {
28554 throw new Error("initializeWasm() must be awaited first!");
28556 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
28557 // debug statements here
28559 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28561 export function ChannelInfo_get_node_one(this_ptr: number): number {
28562 if(!isWasmInitialized) {
28563 throw new Error("initializeWasm() must be awaited first!");
28565 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
28566 return nativeResponseValue;
28568 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28570 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
28571 if(!isWasmInitialized) {
28572 throw new Error("initializeWasm() must be awaited first!");
28574 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
28575 // debug statements here
28577 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28579 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
28580 if(!isWasmInitialized) {
28581 throw new Error("initializeWasm() must be awaited first!");
28583 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
28584 return nativeResponseValue;
28586 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28588 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
28589 if(!isWasmInitialized) {
28590 throw new Error("initializeWasm() must be awaited first!");
28592 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
28593 // debug statements here
28595 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28597 export function ChannelInfo_get_node_two(this_ptr: number): number {
28598 if(!isWasmInitialized) {
28599 throw new Error("initializeWasm() must be awaited first!");
28601 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
28602 return nativeResponseValue;
28604 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28606 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
28607 if(!isWasmInitialized) {
28608 throw new Error("initializeWasm() must be awaited first!");
28610 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
28611 // debug statements here
28613 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28615 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
28616 if(!isWasmInitialized) {
28617 throw new Error("initializeWasm() must be awaited first!");
28619 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
28620 return nativeResponseValue;
28622 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28624 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
28625 if(!isWasmInitialized) {
28626 throw new Error("initializeWasm() must be awaited first!");
28628 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
28629 // debug statements here
28631 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28633 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
28634 if(!isWasmInitialized) {
28635 throw new Error("initializeWasm() must be awaited first!");
28637 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
28638 return nativeResponseValue;
28640 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28642 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
28643 if(!isWasmInitialized) {
28644 throw new Error("initializeWasm() must be awaited first!");
28646 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
28647 // debug statements here
28649 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28651 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
28652 if(!isWasmInitialized) {
28653 throw new Error("initializeWasm() must be awaited first!");
28655 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
28656 return nativeResponseValue;
28658 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
28660 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
28661 if(!isWasmInitialized) {
28662 throw new Error("initializeWasm() must be awaited first!");
28664 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
28665 // debug statements here
28667 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
28669 export function ChannelInfo_clone_ptr(arg: number): number {
28670 if(!isWasmInitialized) {
28671 throw new Error("initializeWasm() must be awaited first!");
28673 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
28674 return nativeResponseValue;
28676 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
28678 export function ChannelInfo_clone(orig: number): number {
28679 if(!isWasmInitialized) {
28680 throw new Error("initializeWasm() must be awaited first!");
28682 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
28683 return nativeResponseValue;
28685 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
28687 export function ChannelInfo_get_directional_info(this_arg: number, channel_flags: number): number {
28688 if(!isWasmInitialized) {
28689 throw new Error("initializeWasm() must be awaited first!");
28691 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
28692 return nativeResponseValue;
28694 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
28696 export function ChannelInfo_write(obj: number): number {
28697 if(!isWasmInitialized) {
28698 throw new Error("initializeWasm() must be awaited first!");
28700 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
28701 return nativeResponseValue;
28703 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
28705 export function ChannelInfo_read(ser: number): number {
28706 if(!isWasmInitialized) {
28707 throw new Error("initializeWasm() must be awaited first!");
28709 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
28710 return nativeResponseValue;
28712 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
28714 export function DirectedChannelInfo_free(this_obj: number): void {
28715 if(!isWasmInitialized) {
28716 throw new Error("initializeWasm() must be awaited first!");
28718 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
28719 // debug statements here
28721 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
28723 export function DirectedChannelInfo_clone_ptr(arg: number): number {
28724 if(!isWasmInitialized) {
28725 throw new Error("initializeWasm() must be awaited first!");
28727 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
28728 return nativeResponseValue;
28730 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
28732 export function DirectedChannelInfo_clone(orig: number): number {
28733 if(!isWasmInitialized) {
28734 throw new Error("initializeWasm() must be awaited first!");
28736 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
28737 return nativeResponseValue;
28739 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28741 export function DirectedChannelInfo_channel(this_arg: number): number {
28742 if(!isWasmInitialized) {
28743 throw new Error("initializeWasm() must be awaited first!");
28745 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
28746 return nativeResponseValue;
28748 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28750 export function DirectedChannelInfo_direction(this_arg: number): number {
28751 if(!isWasmInitialized) {
28752 throw new Error("initializeWasm() must be awaited first!");
28754 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
28755 return nativeResponseValue;
28757 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28759 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: number): bigint {
28760 if(!isWasmInitialized) {
28761 throw new Error("initializeWasm() must be awaited first!");
28763 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
28764 return nativeResponseValue;
28766 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28768 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
28769 if(!isWasmInitialized) {
28770 throw new Error("initializeWasm() must be awaited first!");
28772 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
28773 return nativeResponseValue;
28775 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
28777 export function EffectiveCapacity_free(this_ptr: number): void {
28778 if(!isWasmInitialized) {
28779 throw new Error("initializeWasm() must be awaited first!");
28781 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
28782 // debug statements here
28784 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
28786 export function EffectiveCapacity_clone_ptr(arg: number): number {
28787 if(!isWasmInitialized) {
28788 throw new Error("initializeWasm() must be awaited first!");
28790 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
28791 return nativeResponseValue;
28793 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
28795 export function EffectiveCapacity_clone(orig: number): number {
28796 if(!isWasmInitialized) {
28797 throw new Error("initializeWasm() must be awaited first!");
28799 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
28800 return nativeResponseValue;
28802 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
28804 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
28805 if(!isWasmInitialized) {
28806 throw new Error("initializeWasm() must be awaited first!");
28808 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
28809 return nativeResponseValue;
28811 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
28813 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
28814 if(!isWasmInitialized) {
28815 throw new Error("initializeWasm() must be awaited first!");
28817 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
28818 return nativeResponseValue;
28820 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat);
28822 export function EffectiveCapacity_total(capacity_msat: bigint): number {
28823 if(!isWasmInitialized) {
28824 throw new Error("initializeWasm() must be awaited first!");
28826 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat);
28827 return nativeResponseValue;
28829 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
28831 export function EffectiveCapacity_infinite(): number {
28832 if(!isWasmInitialized) {
28833 throw new Error("initializeWasm() must be awaited first!");
28835 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
28836 return nativeResponseValue;
28838 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
28840 export function EffectiveCapacity_unknown(): number {
28841 if(!isWasmInitialized) {
28842 throw new Error("initializeWasm() must be awaited first!");
28844 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
28845 return nativeResponseValue;
28847 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
28849 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
28850 if(!isWasmInitialized) {
28851 throw new Error("initializeWasm() must be awaited first!");
28853 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
28854 return nativeResponseValue;
28856 // void RoutingFees_free(struct LDKRoutingFees this_obj);
28858 export function RoutingFees_free(this_obj: number): void {
28859 if(!isWasmInitialized) {
28860 throw new Error("initializeWasm() must be awaited first!");
28862 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
28863 // debug statements here
28865 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
28867 export function RoutingFees_get_base_msat(this_ptr: number): number {
28868 if(!isWasmInitialized) {
28869 throw new Error("initializeWasm() must be awaited first!");
28871 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
28872 return nativeResponseValue;
28874 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
28876 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
28877 if(!isWasmInitialized) {
28878 throw new Error("initializeWasm() must be awaited first!");
28880 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
28881 // debug statements here
28883 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
28885 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
28886 if(!isWasmInitialized) {
28887 throw new Error("initializeWasm() must be awaited first!");
28889 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
28890 return nativeResponseValue;
28892 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
28894 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
28895 if(!isWasmInitialized) {
28896 throw new Error("initializeWasm() must be awaited first!");
28898 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
28899 // debug statements here
28901 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
28903 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
28904 if(!isWasmInitialized) {
28905 throw new Error("initializeWasm() must be awaited first!");
28907 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
28908 return nativeResponseValue;
28910 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
28912 export function RoutingFees_eq(a: number, b: number): boolean {
28913 if(!isWasmInitialized) {
28914 throw new Error("initializeWasm() must be awaited first!");
28916 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
28917 return nativeResponseValue;
28919 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
28921 export function RoutingFees_clone_ptr(arg: number): number {
28922 if(!isWasmInitialized) {
28923 throw new Error("initializeWasm() must be awaited first!");
28925 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
28926 return nativeResponseValue;
28928 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
28930 export function RoutingFees_clone(orig: number): number {
28931 if(!isWasmInitialized) {
28932 throw new Error("initializeWasm() must be awaited first!");
28934 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
28935 return nativeResponseValue;
28937 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
28939 export function RoutingFees_hash(o: number): bigint {
28940 if(!isWasmInitialized) {
28941 throw new Error("initializeWasm() must be awaited first!");
28943 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
28944 return nativeResponseValue;
28946 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
28948 export function RoutingFees_write(obj: number): number {
28949 if(!isWasmInitialized) {
28950 throw new Error("initializeWasm() must be awaited first!");
28952 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
28953 return nativeResponseValue;
28955 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
28957 export function RoutingFees_read(ser: number): number {
28958 if(!isWasmInitialized) {
28959 throw new Error("initializeWasm() must be awaited first!");
28961 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
28962 return nativeResponseValue;
28964 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
28966 export function NodeAnnouncementInfo_free(this_obj: number): void {
28967 if(!isWasmInitialized) {
28968 throw new Error("initializeWasm() must be awaited first!");
28970 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
28971 // debug statements here
28973 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
28975 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
28976 if(!isWasmInitialized) {
28977 throw new Error("initializeWasm() must be awaited first!");
28979 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
28980 return nativeResponseValue;
28982 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
28984 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
28985 if(!isWasmInitialized) {
28986 throw new Error("initializeWasm() must be awaited first!");
28988 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
28989 // debug statements here
28991 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
28993 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
28994 if(!isWasmInitialized) {
28995 throw new Error("initializeWasm() must be awaited first!");
28997 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
28998 return nativeResponseValue;
29000 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29002 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
29003 if(!isWasmInitialized) {
29004 throw new Error("initializeWasm() must be awaited first!");
29006 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29007 // debug statements here
29009 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29011 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
29012 if(!isWasmInitialized) {
29013 throw new Error("initializeWasm() must be awaited first!");
29015 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29016 return nativeResponseValue;
29018 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29020 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
29021 if(!isWasmInitialized) {
29022 throw new Error("initializeWasm() must be awaited first!");
29024 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29025 // debug statements here
29027 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
29029 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
29030 if(!isWasmInitialized) {
29031 throw new Error("initializeWasm() must be awaited first!");
29033 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29034 return nativeResponseValue;
29036 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29038 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
29039 if(!isWasmInitialized) {
29040 throw new Error("initializeWasm() must be awaited first!");
29042 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29043 // debug statements here
29045 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29047 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
29048 if(!isWasmInitialized) {
29049 throw new Error("initializeWasm() must be awaited first!");
29051 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29052 // debug statements here
29054 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29056 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
29057 if(!isWasmInitialized) {
29058 throw new Error("initializeWasm() must be awaited first!");
29060 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29061 return nativeResponseValue;
29063 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29065 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
29066 if(!isWasmInitialized) {
29067 throw new Error("initializeWasm() must be awaited first!");
29069 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29070 // debug statements here
29072 // 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);
29074 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 {
29075 if(!isWasmInitialized) {
29076 throw new Error("initializeWasm() must be awaited first!");
29078 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29079 return nativeResponseValue;
29081 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29083 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
29084 if(!isWasmInitialized) {
29085 throw new Error("initializeWasm() must be awaited first!");
29087 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29088 return nativeResponseValue;
29090 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29092 export function NodeAnnouncementInfo_clone(orig: number): number {
29093 if(!isWasmInitialized) {
29094 throw new Error("initializeWasm() must be awaited first!");
29096 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29097 return nativeResponseValue;
29099 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29101 export function NodeAnnouncementInfo_write(obj: number): number {
29102 if(!isWasmInitialized) {
29103 throw new Error("initializeWasm() must be awaited first!");
29105 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29106 return nativeResponseValue;
29108 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29110 export function NodeAnnouncementInfo_read(ser: number): number {
29111 if(!isWasmInitialized) {
29112 throw new Error("initializeWasm() must be awaited first!");
29114 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
29115 return nativeResponseValue;
29117 // void NodeInfo_free(struct LDKNodeInfo this_obj);
29119 export function NodeInfo_free(this_obj: number): void {
29120 if(!isWasmInitialized) {
29121 throw new Error("initializeWasm() must be awaited first!");
29123 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
29124 // debug statements here
29126 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
29128 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
29129 if(!isWasmInitialized) {
29130 throw new Error("initializeWasm() must be awaited first!");
29132 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
29133 // debug statements here
29135 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29137 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
29138 if(!isWasmInitialized) {
29139 throw new Error("initializeWasm() must be awaited first!");
29141 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
29142 return nativeResponseValue;
29144 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29146 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
29147 if(!isWasmInitialized) {
29148 throw new Error("initializeWasm() must be awaited first!");
29150 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
29151 // debug statements here
29153 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29155 export function NodeInfo_get_announcement_info(this_ptr: number): number {
29156 if(!isWasmInitialized) {
29157 throw new Error("initializeWasm() must be awaited first!");
29159 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
29160 return nativeResponseValue;
29162 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
29164 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
29165 if(!isWasmInitialized) {
29166 throw new Error("initializeWasm() must be awaited first!");
29168 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
29169 // debug statements here
29171 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
29173 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
29174 if(!isWasmInitialized) {
29175 throw new Error("initializeWasm() must be awaited first!");
29177 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
29178 return nativeResponseValue;
29180 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
29182 export function NodeInfo_clone_ptr(arg: number): number {
29183 if(!isWasmInitialized) {
29184 throw new Error("initializeWasm() must be awaited first!");
29186 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
29187 return nativeResponseValue;
29189 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
29191 export function NodeInfo_clone(orig: number): number {
29192 if(!isWasmInitialized) {
29193 throw new Error("initializeWasm() must be awaited first!");
29195 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
29196 return nativeResponseValue;
29198 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
29200 export function NodeInfo_write(obj: number): number {
29201 if(!isWasmInitialized) {
29202 throw new Error("initializeWasm() must be awaited first!");
29204 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
29205 return nativeResponseValue;
29207 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
29209 export function NodeInfo_read(ser: number): number {
29210 if(!isWasmInitialized) {
29211 throw new Error("initializeWasm() must be awaited first!");
29213 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
29214 return nativeResponseValue;
29216 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
29218 export function NetworkGraph_write(obj: number): number {
29219 if(!isWasmInitialized) {
29220 throw new Error("initializeWasm() must be awaited first!");
29222 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
29223 return nativeResponseValue;
29225 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
29227 export function NetworkGraph_read(ser: number, arg: number): number {
29228 if(!isWasmInitialized) {
29229 throw new Error("initializeWasm() must be awaited first!");
29231 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
29232 return nativeResponseValue;
29234 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
29236 export function NetworkGraph_new(genesis_hash: number, logger: number): number {
29237 if(!isWasmInitialized) {
29238 throw new Error("initializeWasm() must be awaited first!");
29240 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
29241 return nativeResponseValue;
29243 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29245 export function NetworkGraph_read_only(this_arg: number): number {
29246 if(!isWasmInitialized) {
29247 throw new Error("initializeWasm() must be awaited first!");
29249 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
29250 return nativeResponseValue;
29252 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29254 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: number): number {
29255 if(!isWasmInitialized) {
29256 throw new Error("initializeWasm() must be awaited first!");
29258 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
29259 return nativeResponseValue;
29261 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
29263 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: number, last_rapid_gossip_sync_timestamp: number): void {
29264 if(!isWasmInitialized) {
29265 throw new Error("initializeWasm() must be awaited first!");
29267 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
29268 // debug statements here
29270 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
29272 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
29273 if(!isWasmInitialized) {
29274 throw new Error("initializeWasm() must be awaited first!");
29276 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
29277 return nativeResponseValue;
29279 // 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);
29281 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
29282 if(!isWasmInitialized) {
29283 throw new Error("initializeWasm() must be awaited first!");
29285 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
29286 return nativeResponseValue;
29288 // 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);
29290 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
29291 if(!isWasmInitialized) {
29292 throw new Error("initializeWasm() must be awaited first!");
29294 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
29295 return nativeResponseValue;
29297 // 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);
29299 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
29300 if(!isWasmInitialized) {
29301 throw new Error("initializeWasm() must be awaited first!");
29303 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
29304 return nativeResponseValue;
29306 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_add_channel_from_partial_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, uint64_t timestamp, struct LDKChannelFeatures features, struct LDKPublicKey node_id_1, struct LDKPublicKey node_id_2);
29308 export function NetworkGraph_add_channel_from_partial_announcement(this_arg: number, short_channel_id: bigint, timestamp: bigint, features: number, node_id_1: number, node_id_2: number): number {
29309 if(!isWasmInitialized) {
29310 throw new Error("initializeWasm() must be awaited first!");
29312 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
29313 return nativeResponseValue;
29315 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
29317 export function NetworkGraph_channel_failed(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
29318 if(!isWasmInitialized) {
29319 throw new Error("initializeWasm() must be awaited first!");
29321 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
29322 // debug statements here
29324 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
29326 export function NetworkGraph_node_failed(this_arg: number, _node_id: number, is_permanent: boolean): void {
29327 if(!isWasmInitialized) {
29328 throw new Error("initializeWasm() must be awaited first!");
29330 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
29331 // debug statements here
29333 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
29335 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
29336 if(!isWasmInitialized) {
29337 throw new Error("initializeWasm() must be awaited first!");
29339 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
29340 // debug statements here
29342 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
29344 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
29345 if(!isWasmInitialized) {
29346 throw new Error("initializeWasm() must be awaited first!");
29348 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
29349 return nativeResponseValue;
29351 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
29353 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
29354 if(!isWasmInitialized) {
29355 throw new Error("initializeWasm() must be awaited first!");
29357 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
29358 return nativeResponseValue;
29360 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
29362 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
29363 if(!isWasmInitialized) {
29364 throw new Error("initializeWasm() must be awaited first!");
29366 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
29367 return nativeResponseValue;
29369 // void RouteHop_free(struct LDKRouteHop this_obj);
29371 export function RouteHop_free(this_obj: number): void {
29372 if(!isWasmInitialized) {
29373 throw new Error("initializeWasm() must be awaited first!");
29375 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
29376 // debug statements here
29378 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29380 export function RouteHop_get_pubkey(this_ptr: number): number {
29381 if(!isWasmInitialized) {
29382 throw new Error("initializeWasm() must be awaited first!");
29384 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
29385 return nativeResponseValue;
29387 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29389 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
29390 if(!isWasmInitialized) {
29391 throw new Error("initializeWasm() must be awaited first!");
29393 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
29394 // debug statements here
29396 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29398 export function RouteHop_get_node_features(this_ptr: number): number {
29399 if(!isWasmInitialized) {
29400 throw new Error("initializeWasm() must be awaited first!");
29402 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
29403 return nativeResponseValue;
29405 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29407 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
29408 if(!isWasmInitialized) {
29409 throw new Error("initializeWasm() must be awaited first!");
29411 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
29412 // debug statements here
29414 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29416 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
29417 if(!isWasmInitialized) {
29418 throw new Error("initializeWasm() must be awaited first!");
29420 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
29421 return nativeResponseValue;
29423 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29425 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
29426 if(!isWasmInitialized) {
29427 throw new Error("initializeWasm() must be awaited first!");
29429 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
29430 // debug statements here
29432 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29434 export function RouteHop_get_channel_features(this_ptr: number): number {
29435 if(!isWasmInitialized) {
29436 throw new Error("initializeWasm() must be awaited first!");
29438 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
29439 return nativeResponseValue;
29441 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29443 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
29444 if(!isWasmInitialized) {
29445 throw new Error("initializeWasm() must be awaited first!");
29447 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
29448 // debug statements here
29450 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29452 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
29453 if(!isWasmInitialized) {
29454 throw new Error("initializeWasm() must be awaited first!");
29456 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
29457 return nativeResponseValue;
29459 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29461 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
29462 if(!isWasmInitialized) {
29463 throw new Error("initializeWasm() must be awaited first!");
29465 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
29466 // debug statements here
29468 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29470 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
29471 if(!isWasmInitialized) {
29472 throw new Error("initializeWasm() must be awaited first!");
29474 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
29475 return nativeResponseValue;
29477 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
29479 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
29480 if(!isWasmInitialized) {
29481 throw new Error("initializeWasm() must be awaited first!");
29483 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
29484 // debug statements here
29486 // 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);
29488 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 {
29489 if(!isWasmInitialized) {
29490 throw new Error("initializeWasm() must be awaited first!");
29492 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);
29493 return nativeResponseValue;
29495 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
29497 export function RouteHop_clone_ptr(arg: number): number {
29498 if(!isWasmInitialized) {
29499 throw new Error("initializeWasm() must be awaited first!");
29501 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
29502 return nativeResponseValue;
29504 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
29506 export function RouteHop_clone(orig: number): number {
29507 if(!isWasmInitialized) {
29508 throw new Error("initializeWasm() must be awaited first!");
29510 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
29511 return nativeResponseValue;
29513 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
29515 export function RouteHop_hash(o: number): bigint {
29516 if(!isWasmInitialized) {
29517 throw new Error("initializeWasm() must be awaited first!");
29519 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
29520 return nativeResponseValue;
29522 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
29524 export function RouteHop_eq(a: number, b: number): boolean {
29525 if(!isWasmInitialized) {
29526 throw new Error("initializeWasm() must be awaited first!");
29528 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
29529 return nativeResponseValue;
29531 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
29533 export function RouteHop_write(obj: number): number {
29534 if(!isWasmInitialized) {
29535 throw new Error("initializeWasm() must be awaited first!");
29537 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
29538 return nativeResponseValue;
29540 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
29542 export function RouteHop_read(ser: number): number {
29543 if(!isWasmInitialized) {
29544 throw new Error("initializeWasm() must be awaited first!");
29546 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
29547 return nativeResponseValue;
29549 // void Route_free(struct LDKRoute this_obj);
29551 export function Route_free(this_obj: number): void {
29552 if(!isWasmInitialized) {
29553 throw new Error("initializeWasm() must be awaited first!");
29555 const nativeResponseValue = wasm.TS_Route_free(this_obj);
29556 // debug statements here
29558 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
29560 export function Route_get_paths(this_ptr: number): number {
29561 if(!isWasmInitialized) {
29562 throw new Error("initializeWasm() must be awaited first!");
29564 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
29565 return nativeResponseValue;
29567 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
29569 export function Route_set_paths(this_ptr: number, val: number): void {
29570 if(!isWasmInitialized) {
29571 throw new Error("initializeWasm() must be awaited first!");
29573 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
29574 // debug statements here
29576 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
29578 export function Route_get_payment_params(this_ptr: number): number {
29579 if(!isWasmInitialized) {
29580 throw new Error("initializeWasm() must be awaited first!");
29582 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
29583 return nativeResponseValue;
29585 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
29587 export function Route_set_payment_params(this_ptr: number, val: number): void {
29588 if(!isWasmInitialized) {
29589 throw new Error("initializeWasm() must be awaited first!");
29591 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
29592 // debug statements here
29594 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
29596 export function Route_new(paths_arg: number, payment_params_arg: number): number {
29597 if(!isWasmInitialized) {
29598 throw new Error("initializeWasm() must be awaited first!");
29600 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
29601 return nativeResponseValue;
29603 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
29605 export function Route_clone_ptr(arg: number): number {
29606 if(!isWasmInitialized) {
29607 throw new Error("initializeWasm() must be awaited first!");
29609 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
29610 return nativeResponseValue;
29612 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
29614 export function Route_clone(orig: number): number {
29615 if(!isWasmInitialized) {
29616 throw new Error("initializeWasm() must be awaited first!");
29618 const nativeResponseValue = wasm.TS_Route_clone(orig);
29619 return nativeResponseValue;
29621 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
29623 export function Route_hash(o: number): bigint {
29624 if(!isWasmInitialized) {
29625 throw new Error("initializeWasm() must be awaited first!");
29627 const nativeResponseValue = wasm.TS_Route_hash(o);
29628 return nativeResponseValue;
29630 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
29632 export function Route_eq(a: number, b: number): boolean {
29633 if(!isWasmInitialized) {
29634 throw new Error("initializeWasm() must be awaited first!");
29636 const nativeResponseValue = wasm.TS_Route_eq(a, b);
29637 return nativeResponseValue;
29639 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
29641 export function Route_get_total_fees(this_arg: number): bigint {
29642 if(!isWasmInitialized) {
29643 throw new Error("initializeWasm() must be awaited first!");
29645 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
29646 return nativeResponseValue;
29648 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
29650 export function Route_get_total_amount(this_arg: number): bigint {
29651 if(!isWasmInitialized) {
29652 throw new Error("initializeWasm() must be awaited first!");
29654 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
29655 return nativeResponseValue;
29657 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
29659 export function Route_write(obj: number): number {
29660 if(!isWasmInitialized) {
29661 throw new Error("initializeWasm() must be awaited first!");
29663 const nativeResponseValue = wasm.TS_Route_write(obj);
29664 return nativeResponseValue;
29666 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
29668 export function Route_read(ser: number): number {
29669 if(!isWasmInitialized) {
29670 throw new Error("initializeWasm() must be awaited first!");
29672 const nativeResponseValue = wasm.TS_Route_read(ser);
29673 return nativeResponseValue;
29675 // void RouteParameters_free(struct LDKRouteParameters this_obj);
29677 export function RouteParameters_free(this_obj: number): void {
29678 if(!isWasmInitialized) {
29679 throw new Error("initializeWasm() must be awaited first!");
29681 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
29682 // debug statements here
29684 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
29686 export function RouteParameters_get_payment_params(this_ptr: number): number {
29687 if(!isWasmInitialized) {
29688 throw new Error("initializeWasm() must be awaited first!");
29690 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
29691 return nativeResponseValue;
29693 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
29695 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
29696 if(!isWasmInitialized) {
29697 throw new Error("initializeWasm() must be awaited first!");
29699 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
29700 // debug statements here
29702 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
29704 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
29705 if(!isWasmInitialized) {
29706 throw new Error("initializeWasm() must be awaited first!");
29708 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
29709 return nativeResponseValue;
29711 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
29713 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
29714 if(!isWasmInitialized) {
29715 throw new Error("initializeWasm() must be awaited first!");
29717 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
29718 // debug statements here
29720 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
29722 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
29723 if(!isWasmInitialized) {
29724 throw new Error("initializeWasm() must be awaited first!");
29726 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
29727 return nativeResponseValue;
29729 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
29731 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
29732 if(!isWasmInitialized) {
29733 throw new Error("initializeWasm() must be awaited first!");
29735 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
29736 // debug statements here
29738 // MUST_USE_RES struct LDKRouteParameters RouteParameters_new(struct LDKPaymentParameters payment_params_arg, uint64_t final_value_msat_arg, uint32_t final_cltv_expiry_delta_arg);
29740 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
29741 if(!isWasmInitialized) {
29742 throw new Error("initializeWasm() must be awaited first!");
29744 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
29745 return nativeResponseValue;
29747 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
29749 export function RouteParameters_clone_ptr(arg: number): number {
29750 if(!isWasmInitialized) {
29751 throw new Error("initializeWasm() must be awaited first!");
29753 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
29754 return nativeResponseValue;
29756 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
29758 export function RouteParameters_clone(orig: number): number {
29759 if(!isWasmInitialized) {
29760 throw new Error("initializeWasm() must be awaited first!");
29762 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
29763 return nativeResponseValue;
29765 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
29767 export function RouteParameters_write(obj: number): number {
29768 if(!isWasmInitialized) {
29769 throw new Error("initializeWasm() must be awaited first!");
29771 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
29772 return nativeResponseValue;
29774 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
29776 export function RouteParameters_read(ser: number): number {
29777 if(!isWasmInitialized) {
29778 throw new Error("initializeWasm() must be awaited first!");
29780 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
29781 return nativeResponseValue;
29783 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
29785 export function PaymentParameters_free(this_obj: number): void {
29786 if(!isWasmInitialized) {
29787 throw new Error("initializeWasm() must be awaited first!");
29789 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
29790 // debug statements here
29792 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29794 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
29795 if(!isWasmInitialized) {
29796 throw new Error("initializeWasm() must be awaited first!");
29798 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
29799 return nativeResponseValue;
29801 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29803 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
29804 if(!isWasmInitialized) {
29805 throw new Error("initializeWasm() must be awaited first!");
29807 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
29808 // debug statements here
29810 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29812 export function PaymentParameters_get_features(this_ptr: number): number {
29813 if(!isWasmInitialized) {
29814 throw new Error("initializeWasm() must be awaited first!");
29816 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
29817 return nativeResponseValue;
29819 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
29821 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
29822 if(!isWasmInitialized) {
29823 throw new Error("initializeWasm() must be awaited first!");
29825 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
29826 // debug statements here
29828 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29830 export function PaymentParameters_get_route_hints(this_ptr: number): number {
29831 if(!isWasmInitialized) {
29832 throw new Error("initializeWasm() must be awaited first!");
29834 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
29835 return nativeResponseValue;
29837 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
29839 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
29840 if(!isWasmInitialized) {
29841 throw new Error("initializeWasm() must be awaited first!");
29843 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
29844 // debug statements here
29846 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29848 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
29849 if(!isWasmInitialized) {
29850 throw new Error("initializeWasm() must be awaited first!");
29852 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
29853 return nativeResponseValue;
29855 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29857 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
29858 if(!isWasmInitialized) {
29859 throw new Error("initializeWasm() must be awaited first!");
29861 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
29862 // debug statements here
29864 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29866 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
29867 if(!isWasmInitialized) {
29868 throw new Error("initializeWasm() must be awaited first!");
29870 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
29871 return nativeResponseValue;
29873 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
29875 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
29876 if(!isWasmInitialized) {
29877 throw new Error("initializeWasm() must be awaited first!");
29879 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
29880 // debug statements here
29882 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg);
29884 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: number, route_hints_arg: number, expiry_time_arg: number, max_total_cltv_expiry_delta_arg: number): number {
29885 if(!isWasmInitialized) {
29886 throw new Error("initializeWasm() must be awaited first!");
29888 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg);
29889 return nativeResponseValue;
29891 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
29893 export function PaymentParameters_clone_ptr(arg: number): number {
29894 if(!isWasmInitialized) {
29895 throw new Error("initializeWasm() must be awaited first!");
29897 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
29898 return nativeResponseValue;
29900 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
29902 export function PaymentParameters_clone(orig: number): number {
29903 if(!isWasmInitialized) {
29904 throw new Error("initializeWasm() must be awaited first!");
29906 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
29907 return nativeResponseValue;
29909 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
29911 export function PaymentParameters_hash(o: number): bigint {
29912 if(!isWasmInitialized) {
29913 throw new Error("initializeWasm() must be awaited first!");
29915 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
29916 return nativeResponseValue;
29918 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
29920 export function PaymentParameters_eq(a: number, b: number): boolean {
29921 if(!isWasmInitialized) {
29922 throw new Error("initializeWasm() must be awaited first!");
29924 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
29925 return nativeResponseValue;
29927 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
29929 export function PaymentParameters_write(obj: number): number {
29930 if(!isWasmInitialized) {
29931 throw new Error("initializeWasm() must be awaited first!");
29933 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
29934 return nativeResponseValue;
29936 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
29938 export function PaymentParameters_read(ser: number): number {
29939 if(!isWasmInitialized) {
29940 throw new Error("initializeWasm() must be awaited first!");
29942 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
29943 return nativeResponseValue;
29945 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
29947 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
29948 if(!isWasmInitialized) {
29949 throw new Error("initializeWasm() must be awaited first!");
29951 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
29952 return nativeResponseValue;
29954 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
29956 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
29957 if(!isWasmInitialized) {
29958 throw new Error("initializeWasm() must be awaited first!");
29960 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
29961 return nativeResponseValue;
29963 // void RouteHint_free(struct LDKRouteHint this_obj);
29965 export function RouteHint_free(this_obj: number): void {
29966 if(!isWasmInitialized) {
29967 throw new Error("initializeWasm() must be awaited first!");
29969 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
29970 // debug statements here
29972 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
29974 export function RouteHint_get_a(this_ptr: number): number {
29975 if(!isWasmInitialized) {
29976 throw new Error("initializeWasm() must be awaited first!");
29978 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
29979 return nativeResponseValue;
29981 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
29983 export function RouteHint_set_a(this_ptr: number, val: number): void {
29984 if(!isWasmInitialized) {
29985 throw new Error("initializeWasm() must be awaited first!");
29987 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
29988 // debug statements here
29990 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
29992 export function RouteHint_new(a_arg: number): number {
29993 if(!isWasmInitialized) {
29994 throw new Error("initializeWasm() must be awaited first!");
29996 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
29997 return nativeResponseValue;
29999 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
30001 export function RouteHint_clone_ptr(arg: number): number {
30002 if(!isWasmInitialized) {
30003 throw new Error("initializeWasm() must be awaited first!");
30005 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
30006 return nativeResponseValue;
30008 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
30010 export function RouteHint_clone(orig: number): number {
30011 if(!isWasmInitialized) {
30012 throw new Error("initializeWasm() must be awaited first!");
30014 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
30015 return nativeResponseValue;
30017 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
30019 export function RouteHint_hash(o: number): bigint {
30020 if(!isWasmInitialized) {
30021 throw new Error("initializeWasm() must be awaited first!");
30023 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
30024 return nativeResponseValue;
30026 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
30028 export function RouteHint_eq(a: number, b: number): boolean {
30029 if(!isWasmInitialized) {
30030 throw new Error("initializeWasm() must be awaited first!");
30032 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
30033 return nativeResponseValue;
30035 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
30037 export function RouteHint_write(obj: number): number {
30038 if(!isWasmInitialized) {
30039 throw new Error("initializeWasm() must be awaited first!");
30041 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
30042 return nativeResponseValue;
30044 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
30046 export function RouteHint_read(ser: number): number {
30047 if(!isWasmInitialized) {
30048 throw new Error("initializeWasm() must be awaited first!");
30050 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
30051 return nativeResponseValue;
30053 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
30055 export function RouteHintHop_free(this_obj: number): void {
30056 if(!isWasmInitialized) {
30057 throw new Error("initializeWasm() must be awaited first!");
30059 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
30060 // debug statements here
30062 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30064 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
30065 if(!isWasmInitialized) {
30066 throw new Error("initializeWasm() must be awaited first!");
30068 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
30069 return nativeResponseValue;
30071 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30073 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
30074 if(!isWasmInitialized) {
30075 throw new Error("initializeWasm() must be awaited first!");
30077 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
30078 // debug statements here
30080 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30082 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
30083 if(!isWasmInitialized) {
30084 throw new Error("initializeWasm() must be awaited first!");
30086 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
30087 return nativeResponseValue;
30089 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
30091 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
30092 if(!isWasmInitialized) {
30093 throw new Error("initializeWasm() must be awaited first!");
30095 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
30096 // debug statements here
30098 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30100 export function RouteHintHop_get_fees(this_ptr: number): number {
30101 if(!isWasmInitialized) {
30102 throw new Error("initializeWasm() must be awaited first!");
30104 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
30105 return nativeResponseValue;
30107 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30109 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
30110 if(!isWasmInitialized) {
30111 throw new Error("initializeWasm() must be awaited first!");
30113 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
30114 // debug statements here
30116 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30118 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
30119 if(!isWasmInitialized) {
30120 throw new Error("initializeWasm() must be awaited first!");
30122 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
30123 return nativeResponseValue;
30125 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
30127 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
30128 if(!isWasmInitialized) {
30129 throw new Error("initializeWasm() must be awaited first!");
30131 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
30132 // debug statements here
30134 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30136 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
30137 if(!isWasmInitialized) {
30138 throw new Error("initializeWasm() must be awaited first!");
30140 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
30141 return nativeResponseValue;
30143 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30145 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
30146 if(!isWasmInitialized) {
30147 throw new Error("initializeWasm() must be awaited first!");
30149 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
30150 // debug statements here
30152 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30154 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
30155 if(!isWasmInitialized) {
30156 throw new Error("initializeWasm() must be awaited first!");
30158 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
30159 return nativeResponseValue;
30161 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30163 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
30164 if(!isWasmInitialized) {
30165 throw new Error("initializeWasm() must be awaited first!");
30167 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
30168 // debug statements here
30170 // 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);
30172 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 {
30173 if(!isWasmInitialized) {
30174 throw new Error("initializeWasm() must be awaited first!");
30176 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);
30177 return nativeResponseValue;
30179 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
30181 export function RouteHintHop_clone_ptr(arg: number): number {
30182 if(!isWasmInitialized) {
30183 throw new Error("initializeWasm() must be awaited first!");
30185 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
30186 return nativeResponseValue;
30188 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
30190 export function RouteHintHop_clone(orig: number): number {
30191 if(!isWasmInitialized) {
30192 throw new Error("initializeWasm() must be awaited first!");
30194 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
30195 return nativeResponseValue;
30197 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
30199 export function RouteHintHop_hash(o: number): bigint {
30200 if(!isWasmInitialized) {
30201 throw new Error("initializeWasm() must be awaited first!");
30203 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
30204 return nativeResponseValue;
30206 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
30208 export function RouteHintHop_eq(a: number, b: number): boolean {
30209 if(!isWasmInitialized) {
30210 throw new Error("initializeWasm() must be awaited first!");
30212 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
30213 return nativeResponseValue;
30215 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
30217 export function RouteHintHop_write(obj: number): number {
30218 if(!isWasmInitialized) {
30219 throw new Error("initializeWasm() must be awaited first!");
30221 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
30222 return nativeResponseValue;
30224 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
30226 export function RouteHintHop_read(ser: number): number {
30227 if(!isWasmInitialized) {
30228 throw new Error("initializeWasm() must be awaited first!");
30230 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
30231 return nativeResponseValue;
30233 // struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer, const uint8_t (*random_seed_bytes)[32]);
30235 export function find_route(our_node_pubkey: number, route_params: number, network_graph: number, first_hops: number, logger: number, scorer: number, random_seed_bytes: number): number {
30236 if(!isWasmInitialized) {
30237 throw new Error("initializeWasm() must be awaited first!");
30239 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
30240 return nativeResponseValue;
30242 // struct LDKCResult_RouteLightningErrorZ build_route_from_hops(struct LDKPublicKey our_node_pubkey, struct LDKCVec_PublicKeyZ hops, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, const uint8_t (*random_seed_bytes)[32]);
30244 export function build_route_from_hops(our_node_pubkey: number, hops: number, route_params: number, network_graph: number, logger: number, random_seed_bytes: number): number {
30245 if(!isWasmInitialized) {
30246 throw new Error("initializeWasm() must be awaited first!");
30248 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
30249 return nativeResponseValue;
30251 // void Score_free(struct LDKScore this_ptr);
30253 export function Score_free(this_ptr: number): void {
30254 if(!isWasmInitialized) {
30255 throw new Error("initializeWasm() must be awaited first!");
30257 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
30258 // debug statements here
30260 // void LockableScore_free(struct LDKLockableScore this_ptr);
30262 export function LockableScore_free(this_ptr: number): void {
30263 if(!isWasmInitialized) {
30264 throw new Error("initializeWasm() must be awaited first!");
30266 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
30267 // debug statements here
30269 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
30271 export function MultiThreadedLockableScore_free(this_obj: number): void {
30272 if(!isWasmInitialized) {
30273 throw new Error("initializeWasm() must be awaited first!");
30275 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
30276 // debug statements here
30278 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
30280 export function MultiThreadedLockableScore_write(obj: number): number {
30281 if(!isWasmInitialized) {
30282 throw new Error("initializeWasm() must be awaited first!");
30284 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
30285 return nativeResponseValue;
30287 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
30289 export function MultiThreadedLockableScore_new(score: number): number {
30290 if(!isWasmInitialized) {
30291 throw new Error("initializeWasm() must be awaited first!");
30293 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
30294 return nativeResponseValue;
30296 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
30298 export function ChannelUsage_free(this_obj: number): void {
30299 if(!isWasmInitialized) {
30300 throw new Error("initializeWasm() must be awaited first!");
30302 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
30303 // debug statements here
30305 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30307 export function ChannelUsage_get_amount_msat(this_ptr: number): bigint {
30308 if(!isWasmInitialized) {
30309 throw new Error("initializeWasm() must be awaited first!");
30311 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
30312 return nativeResponseValue;
30314 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30316 export function ChannelUsage_set_amount_msat(this_ptr: number, val: bigint): void {
30317 if(!isWasmInitialized) {
30318 throw new Error("initializeWasm() must be awaited first!");
30320 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
30321 // debug statements here
30323 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30325 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: number): bigint {
30326 if(!isWasmInitialized) {
30327 throw new Error("initializeWasm() must be awaited first!");
30329 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
30330 return nativeResponseValue;
30332 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30334 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: number, val: bigint): void {
30335 if(!isWasmInitialized) {
30336 throw new Error("initializeWasm() must be awaited first!");
30338 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
30339 // debug statements here
30341 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30343 export function ChannelUsage_get_effective_capacity(this_ptr: number): number {
30344 if(!isWasmInitialized) {
30345 throw new Error("initializeWasm() must be awaited first!");
30347 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
30348 return nativeResponseValue;
30350 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
30352 export function ChannelUsage_set_effective_capacity(this_ptr: number, val: number): void {
30353 if(!isWasmInitialized) {
30354 throw new Error("initializeWasm() must be awaited first!");
30356 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
30357 // debug statements here
30359 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
30361 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: number): number {
30362 if(!isWasmInitialized) {
30363 throw new Error("initializeWasm() must be awaited first!");
30365 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
30366 return nativeResponseValue;
30368 // uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
30370 export function ChannelUsage_clone_ptr(arg: number): number {
30371 if(!isWasmInitialized) {
30372 throw new Error("initializeWasm() must be awaited first!");
30374 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
30375 return nativeResponseValue;
30377 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
30379 export function ChannelUsage_clone(orig: number): number {
30380 if(!isWasmInitialized) {
30381 throw new Error("initializeWasm() must be awaited first!");
30383 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
30384 return nativeResponseValue;
30386 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
30388 export function FixedPenaltyScorer_free(this_obj: number): void {
30389 if(!isWasmInitialized) {
30390 throw new Error("initializeWasm() must be awaited first!");
30392 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
30393 // debug statements here
30395 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
30397 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
30398 if(!isWasmInitialized) {
30399 throw new Error("initializeWasm() must be awaited first!");
30401 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
30402 return nativeResponseValue;
30404 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
30406 export function FixedPenaltyScorer_clone(orig: number): number {
30407 if(!isWasmInitialized) {
30408 throw new Error("initializeWasm() must be awaited first!");
30410 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
30411 return nativeResponseValue;
30413 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
30415 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
30416 if(!isWasmInitialized) {
30417 throw new Error("initializeWasm() must be awaited first!");
30419 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
30420 return nativeResponseValue;
30422 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
30424 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
30425 if(!isWasmInitialized) {
30426 throw new Error("initializeWasm() must be awaited first!");
30428 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
30429 return nativeResponseValue;
30431 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
30433 export function FixedPenaltyScorer_write(obj: number): number {
30434 if(!isWasmInitialized) {
30435 throw new Error("initializeWasm() must be awaited first!");
30437 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
30438 return nativeResponseValue;
30440 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
30442 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
30443 if(!isWasmInitialized) {
30444 throw new Error("initializeWasm() must be awaited first!");
30446 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
30447 return nativeResponseValue;
30449 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
30451 export function ProbabilisticScorer_free(this_obj: number): void {
30452 if(!isWasmInitialized) {
30453 throw new Error("initializeWasm() must be awaited first!");
30455 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
30456 // debug statements here
30458 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
30460 export function ProbabilisticScoringParameters_free(this_obj: number): void {
30461 if(!isWasmInitialized) {
30462 throw new Error("initializeWasm() must be awaited first!");
30464 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
30465 // debug statements here
30467 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30469 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
30470 if(!isWasmInitialized) {
30471 throw new Error("initializeWasm() must be awaited first!");
30473 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
30474 return nativeResponseValue;
30476 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30478 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
30479 if(!isWasmInitialized) {
30480 throw new Error("initializeWasm() must be awaited first!");
30482 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
30483 // debug statements here
30485 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30487 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
30488 if(!isWasmInitialized) {
30489 throw new Error("initializeWasm() must be awaited first!");
30491 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
30492 return nativeResponseValue;
30494 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30496 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30497 if(!isWasmInitialized) {
30498 throw new Error("initializeWasm() must be awaited first!");
30500 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
30501 // debug statements here
30503 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30505 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
30506 if(!isWasmInitialized) {
30507 throw new Error("initializeWasm() must be awaited first!");
30509 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
30510 return nativeResponseValue;
30512 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30514 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
30515 if(!isWasmInitialized) {
30516 throw new Error("initializeWasm() must be awaited first!");
30518 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
30519 // debug statements here
30521 // uint64_t ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30523 export function ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr: number): bigint {
30524 if(!isWasmInitialized) {
30525 throw new Error("initializeWasm() must be awaited first!");
30527 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr);
30528 return nativeResponseValue;
30530 // void ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30532 export function ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30533 if(!isWasmInitialized) {
30534 throw new Error("initializeWasm() must be awaited first!");
30536 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr, val);
30537 // debug statements here
30539 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_new(uint64_t base_penalty_msat_arg, uint64_t liquidity_penalty_multiplier_msat_arg, uint64_t liquidity_offset_half_life_arg, uint64_t amount_penalty_multiplier_msat_arg);
30541 export function ProbabilisticScoringParameters_new(base_penalty_msat_arg: bigint, liquidity_penalty_multiplier_msat_arg: bigint, liquidity_offset_half_life_arg: bigint, amount_penalty_multiplier_msat_arg: bigint): number {
30542 if(!isWasmInitialized) {
30543 throw new Error("initializeWasm() must be awaited first!");
30545 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_new(base_penalty_msat_arg, liquidity_penalty_multiplier_msat_arg, liquidity_offset_half_life_arg, amount_penalty_multiplier_msat_arg);
30546 return nativeResponseValue;
30548 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
30550 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
30551 if(!isWasmInitialized) {
30552 throw new Error("initializeWasm() must be awaited first!");
30554 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
30555 return nativeResponseValue;
30557 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
30559 export function ProbabilisticScoringParameters_clone(orig: number): number {
30560 if(!isWasmInitialized) {
30561 throw new Error("initializeWasm() must be awaited first!");
30563 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
30564 return nativeResponseValue;
30566 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
30568 export function ProbabilisticScorer_new(params: number, network_graph: number, logger: number): number {
30569 if(!isWasmInitialized) {
30570 throw new Error("initializeWasm() must be awaited first!");
30572 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
30573 return nativeResponseValue;
30575 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30577 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: number): void {
30578 if(!isWasmInitialized) {
30579 throw new Error("initializeWasm() must be awaited first!");
30581 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
30582 // debug statements here
30584 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
30586 export function ProbabilisticScoringParameters_default(): number {
30587 if(!isWasmInitialized) {
30588 throw new Error("initializeWasm() must be awaited first!");
30590 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
30591 return nativeResponseValue;
30593 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30595 export function ProbabilisticScorer_as_Score(this_arg: number): number {
30596 if(!isWasmInitialized) {
30597 throw new Error("initializeWasm() must be awaited first!");
30599 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
30600 return nativeResponseValue;
30602 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
30604 export function ProbabilisticScorer_write(obj: number): number {
30605 if(!isWasmInitialized) {
30606 throw new Error("initializeWasm() must be awaited first!");
30608 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
30609 return nativeResponseValue;
30611 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
30613 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number, arg_c: number): number {
30614 if(!isWasmInitialized) {
30615 throw new Error("initializeWasm() must be awaited first!");
30617 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
30618 return nativeResponseValue;
30620 // void ParseError_free(struct LDKParseError this_ptr);
30622 export function ParseError_free(this_ptr: number): void {
30623 if(!isWasmInitialized) {
30624 throw new Error("initializeWasm() must be awaited first!");
30626 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
30627 // debug statements here
30629 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
30631 export function ParseError_clone_ptr(arg: number): number {
30632 if(!isWasmInitialized) {
30633 throw new Error("initializeWasm() must be awaited first!");
30635 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
30636 return nativeResponseValue;
30638 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
30640 export function ParseError_clone(orig: number): number {
30641 if(!isWasmInitialized) {
30642 throw new Error("initializeWasm() must be awaited first!");
30644 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
30645 return nativeResponseValue;
30647 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
30649 export function ParseError_bech32_error(a: number): number {
30650 if(!isWasmInitialized) {
30651 throw new Error("initializeWasm() must be awaited first!");
30653 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
30654 return nativeResponseValue;
30656 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
30658 export function ParseError_parse_amount_error(a: number): number {
30659 if(!isWasmInitialized) {
30660 throw new Error("initializeWasm() must be awaited first!");
30662 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
30663 return nativeResponseValue;
30665 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
30667 export function ParseError_malformed_signature(a: Secp256k1Error): number {
30668 if(!isWasmInitialized) {
30669 throw new Error("initializeWasm() must be awaited first!");
30671 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
30672 return nativeResponseValue;
30674 // struct LDKParseError ParseError_bad_prefix(void);
30676 export function ParseError_bad_prefix(): number {
30677 if(!isWasmInitialized) {
30678 throw new Error("initializeWasm() must be awaited first!");
30680 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
30681 return nativeResponseValue;
30683 // struct LDKParseError ParseError_unknown_currency(void);
30685 export function ParseError_unknown_currency(): number {
30686 if(!isWasmInitialized) {
30687 throw new Error("initializeWasm() must be awaited first!");
30689 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
30690 return nativeResponseValue;
30692 // struct LDKParseError ParseError_unknown_si_prefix(void);
30694 export function ParseError_unknown_si_prefix(): number {
30695 if(!isWasmInitialized) {
30696 throw new Error("initializeWasm() must be awaited first!");
30698 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
30699 return nativeResponseValue;
30701 // struct LDKParseError ParseError_malformed_hrp(void);
30703 export function ParseError_malformed_hrp(): number {
30704 if(!isWasmInitialized) {
30705 throw new Error("initializeWasm() must be awaited first!");
30707 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
30708 return nativeResponseValue;
30710 // struct LDKParseError ParseError_too_short_data_part(void);
30712 export function ParseError_too_short_data_part(): number {
30713 if(!isWasmInitialized) {
30714 throw new Error("initializeWasm() must be awaited first!");
30716 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
30717 return nativeResponseValue;
30719 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
30721 export function ParseError_unexpected_end_of_tagged_fields(): number {
30722 if(!isWasmInitialized) {
30723 throw new Error("initializeWasm() must be awaited first!");
30725 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
30726 return nativeResponseValue;
30728 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
30730 export function ParseError_description_decode_error(a: number): number {
30731 if(!isWasmInitialized) {
30732 throw new Error("initializeWasm() must be awaited first!");
30734 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
30735 return nativeResponseValue;
30737 // struct LDKParseError ParseError_padding_error(void);
30739 export function ParseError_padding_error(): number {
30740 if(!isWasmInitialized) {
30741 throw new Error("initializeWasm() must be awaited first!");
30743 const nativeResponseValue = wasm.TS_ParseError_padding_error();
30744 return nativeResponseValue;
30746 // struct LDKParseError ParseError_integer_overflow_error(void);
30748 export function ParseError_integer_overflow_error(): number {
30749 if(!isWasmInitialized) {
30750 throw new Error("initializeWasm() must be awaited first!");
30752 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
30753 return nativeResponseValue;
30755 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
30757 export function ParseError_invalid_seg_wit_program_length(): number {
30758 if(!isWasmInitialized) {
30759 throw new Error("initializeWasm() must be awaited first!");
30761 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
30762 return nativeResponseValue;
30764 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
30766 export function ParseError_invalid_pub_key_hash_length(): number {
30767 if(!isWasmInitialized) {
30768 throw new Error("initializeWasm() must be awaited first!");
30770 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
30771 return nativeResponseValue;
30773 // struct LDKParseError ParseError_invalid_script_hash_length(void);
30775 export function ParseError_invalid_script_hash_length(): number {
30776 if(!isWasmInitialized) {
30777 throw new Error("initializeWasm() must be awaited first!");
30779 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
30780 return nativeResponseValue;
30782 // struct LDKParseError ParseError_invalid_recovery_id(void);
30784 export function ParseError_invalid_recovery_id(): number {
30785 if(!isWasmInitialized) {
30786 throw new Error("initializeWasm() must be awaited first!");
30788 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
30789 return nativeResponseValue;
30791 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
30793 export function ParseError_invalid_slice_length(a: number): number {
30794 if(!isWasmInitialized) {
30795 throw new Error("initializeWasm() must be awaited first!");
30797 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
30798 return nativeResponseValue;
30800 // struct LDKParseError ParseError_skip(void);
30802 export function ParseError_skip(): number {
30803 if(!isWasmInitialized) {
30804 throw new Error("initializeWasm() must be awaited first!");
30806 const nativeResponseValue = wasm.TS_ParseError_skip();
30807 return nativeResponseValue;
30809 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
30811 export function ParseOrSemanticError_free(this_ptr: number): void {
30812 if(!isWasmInitialized) {
30813 throw new Error("initializeWasm() must be awaited first!");
30815 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
30816 // debug statements here
30818 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
30820 export function ParseOrSemanticError_clone_ptr(arg: number): number {
30821 if(!isWasmInitialized) {
30822 throw new Error("initializeWasm() must be awaited first!");
30824 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
30825 return nativeResponseValue;
30827 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
30829 export function ParseOrSemanticError_clone(orig: number): number {
30830 if(!isWasmInitialized) {
30831 throw new Error("initializeWasm() must be awaited first!");
30833 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
30834 return nativeResponseValue;
30836 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
30838 export function ParseOrSemanticError_parse_error(a: number): number {
30839 if(!isWasmInitialized) {
30840 throw new Error("initializeWasm() must be awaited first!");
30842 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
30843 return nativeResponseValue;
30845 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
30847 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
30848 if(!isWasmInitialized) {
30849 throw new Error("initializeWasm() must be awaited first!");
30851 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
30852 return nativeResponseValue;
30854 // void Invoice_free(struct LDKInvoice this_obj);
30856 export function Invoice_free(this_obj: number): void {
30857 if(!isWasmInitialized) {
30858 throw new Error("initializeWasm() must be awaited first!");
30860 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
30861 // debug statements here
30863 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
30865 export function Invoice_eq(a: number, b: number): boolean {
30866 if(!isWasmInitialized) {
30867 throw new Error("initializeWasm() must be awaited first!");
30869 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
30870 return nativeResponseValue;
30872 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
30874 export function Invoice_clone_ptr(arg: number): number {
30875 if(!isWasmInitialized) {
30876 throw new Error("initializeWasm() must be awaited first!");
30878 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
30879 return nativeResponseValue;
30881 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
30883 export function Invoice_clone(orig: number): number {
30884 if(!isWasmInitialized) {
30885 throw new Error("initializeWasm() must be awaited first!");
30887 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
30888 return nativeResponseValue;
30890 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
30892 export function SignedRawInvoice_free(this_obj: number): void {
30893 if(!isWasmInitialized) {
30894 throw new Error("initializeWasm() must be awaited first!");
30896 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
30897 // debug statements here
30899 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
30901 export function SignedRawInvoice_eq(a: number, b: number): boolean {
30902 if(!isWasmInitialized) {
30903 throw new Error("initializeWasm() must be awaited first!");
30905 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
30906 return nativeResponseValue;
30908 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
30910 export function SignedRawInvoice_clone_ptr(arg: number): number {
30911 if(!isWasmInitialized) {
30912 throw new Error("initializeWasm() must be awaited first!");
30914 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
30915 return nativeResponseValue;
30917 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
30919 export function SignedRawInvoice_clone(orig: number): number {
30920 if(!isWasmInitialized) {
30921 throw new Error("initializeWasm() must be awaited first!");
30923 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
30924 return nativeResponseValue;
30926 // void RawInvoice_free(struct LDKRawInvoice this_obj);
30928 export function RawInvoice_free(this_obj: number): void {
30929 if(!isWasmInitialized) {
30930 throw new Error("initializeWasm() must be awaited first!");
30932 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
30933 // debug statements here
30935 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
30937 export function RawInvoice_get_data(this_ptr: number): number {
30938 if(!isWasmInitialized) {
30939 throw new Error("initializeWasm() must be awaited first!");
30941 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
30942 return nativeResponseValue;
30944 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
30946 export function RawInvoice_set_data(this_ptr: number, val: number): void {
30947 if(!isWasmInitialized) {
30948 throw new Error("initializeWasm() must be awaited first!");
30950 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
30951 // debug statements here
30953 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
30955 export function RawInvoice_eq(a: number, b: number): boolean {
30956 if(!isWasmInitialized) {
30957 throw new Error("initializeWasm() must be awaited first!");
30959 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
30960 return nativeResponseValue;
30962 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
30964 export function RawInvoice_clone_ptr(arg: number): number {
30965 if(!isWasmInitialized) {
30966 throw new Error("initializeWasm() must be awaited first!");
30968 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
30969 return nativeResponseValue;
30971 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
30973 export function RawInvoice_clone(orig: number): number {
30974 if(!isWasmInitialized) {
30975 throw new Error("initializeWasm() must be awaited first!");
30977 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
30978 return nativeResponseValue;
30980 // void RawDataPart_free(struct LDKRawDataPart this_obj);
30982 export function RawDataPart_free(this_obj: number): void {
30983 if(!isWasmInitialized) {
30984 throw new Error("initializeWasm() must be awaited first!");
30986 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
30987 // debug statements here
30989 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
30991 export function RawDataPart_get_timestamp(this_ptr: number): number {
30992 if(!isWasmInitialized) {
30993 throw new Error("initializeWasm() must be awaited first!");
30995 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
30996 return nativeResponseValue;
30998 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
31000 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
31001 if(!isWasmInitialized) {
31002 throw new Error("initializeWasm() must be awaited first!");
31004 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
31005 // debug statements here
31007 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
31009 export function RawDataPart_eq(a: number, b: number): boolean {
31010 if(!isWasmInitialized) {
31011 throw new Error("initializeWasm() must be awaited first!");
31013 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
31014 return nativeResponseValue;
31016 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
31018 export function RawDataPart_clone_ptr(arg: number): number {
31019 if(!isWasmInitialized) {
31020 throw new Error("initializeWasm() must be awaited first!");
31022 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
31023 return nativeResponseValue;
31025 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
31027 export function RawDataPart_clone(orig: number): number {
31028 if(!isWasmInitialized) {
31029 throw new Error("initializeWasm() must be awaited first!");
31031 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
31032 return nativeResponseValue;
31034 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
31036 export function PositiveTimestamp_free(this_obj: number): void {
31037 if(!isWasmInitialized) {
31038 throw new Error("initializeWasm() must be awaited first!");
31040 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
31041 // debug statements here
31043 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
31045 export function PositiveTimestamp_eq(a: number, b: number): boolean {
31046 if(!isWasmInitialized) {
31047 throw new Error("initializeWasm() must be awaited first!");
31049 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
31050 return nativeResponseValue;
31052 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
31054 export function PositiveTimestamp_clone_ptr(arg: number): number {
31055 if(!isWasmInitialized) {
31056 throw new Error("initializeWasm() must be awaited first!");
31058 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
31059 return nativeResponseValue;
31061 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
31063 export function PositiveTimestamp_clone(orig: number): number {
31064 if(!isWasmInitialized) {
31065 throw new Error("initializeWasm() must be awaited first!");
31067 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
31068 return nativeResponseValue;
31070 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
31072 export function SiPrefix_clone(orig: number): SiPrefix {
31073 if(!isWasmInitialized) {
31074 throw new Error("initializeWasm() must be awaited first!");
31076 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
31077 return nativeResponseValue;
31079 // enum LDKSiPrefix SiPrefix_milli(void);
31081 export function SiPrefix_milli(): SiPrefix {
31082 if(!isWasmInitialized) {
31083 throw new Error("initializeWasm() must be awaited first!");
31085 const nativeResponseValue = wasm.TS_SiPrefix_milli();
31086 return nativeResponseValue;
31088 // enum LDKSiPrefix SiPrefix_micro(void);
31090 export function SiPrefix_micro(): SiPrefix {
31091 if(!isWasmInitialized) {
31092 throw new Error("initializeWasm() must be awaited first!");
31094 const nativeResponseValue = wasm.TS_SiPrefix_micro();
31095 return nativeResponseValue;
31097 // enum LDKSiPrefix SiPrefix_nano(void);
31099 export function SiPrefix_nano(): SiPrefix {
31100 if(!isWasmInitialized) {
31101 throw new Error("initializeWasm() must be awaited first!");
31103 const nativeResponseValue = wasm.TS_SiPrefix_nano();
31104 return nativeResponseValue;
31106 // enum LDKSiPrefix SiPrefix_pico(void);
31108 export function SiPrefix_pico(): SiPrefix {
31109 if(!isWasmInitialized) {
31110 throw new Error("initializeWasm() must be awaited first!");
31112 const nativeResponseValue = wasm.TS_SiPrefix_pico();
31113 return nativeResponseValue;
31115 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
31117 export function SiPrefix_eq(a: number, b: number): boolean {
31118 if(!isWasmInitialized) {
31119 throw new Error("initializeWasm() must be awaited first!");
31121 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
31122 return nativeResponseValue;
31124 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
31126 export function SiPrefix_multiplier(this_arg: number): bigint {
31127 if(!isWasmInitialized) {
31128 throw new Error("initializeWasm() must be awaited first!");
31130 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
31131 return nativeResponseValue;
31133 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
31135 export function Currency_clone(orig: number): Currency {
31136 if(!isWasmInitialized) {
31137 throw new Error("initializeWasm() must be awaited first!");
31139 const nativeResponseValue = wasm.TS_Currency_clone(orig);
31140 return nativeResponseValue;
31142 // enum LDKCurrency Currency_bitcoin(void);
31144 export function Currency_bitcoin(): Currency {
31145 if(!isWasmInitialized) {
31146 throw new Error("initializeWasm() must be awaited first!");
31148 const nativeResponseValue = wasm.TS_Currency_bitcoin();
31149 return nativeResponseValue;
31151 // enum LDKCurrency Currency_bitcoin_testnet(void);
31153 export function Currency_bitcoin_testnet(): Currency {
31154 if(!isWasmInitialized) {
31155 throw new Error("initializeWasm() must be awaited first!");
31157 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
31158 return nativeResponseValue;
31160 // enum LDKCurrency Currency_regtest(void);
31162 export function Currency_regtest(): Currency {
31163 if(!isWasmInitialized) {
31164 throw new Error("initializeWasm() must be awaited first!");
31166 const nativeResponseValue = wasm.TS_Currency_regtest();
31167 return nativeResponseValue;
31169 // enum LDKCurrency Currency_simnet(void);
31171 export function Currency_simnet(): Currency {
31172 if(!isWasmInitialized) {
31173 throw new Error("initializeWasm() must be awaited first!");
31175 const nativeResponseValue = wasm.TS_Currency_simnet();
31176 return nativeResponseValue;
31178 // enum LDKCurrency Currency_signet(void);
31180 export function Currency_signet(): Currency {
31181 if(!isWasmInitialized) {
31182 throw new Error("initializeWasm() must be awaited first!");
31184 const nativeResponseValue = wasm.TS_Currency_signet();
31185 return nativeResponseValue;
31187 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
31189 export function Currency_hash(o: number): bigint {
31190 if(!isWasmInitialized) {
31191 throw new Error("initializeWasm() must be awaited first!");
31193 const nativeResponseValue = wasm.TS_Currency_hash(o);
31194 return nativeResponseValue;
31196 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
31198 export function Currency_eq(a: number, b: number): boolean {
31199 if(!isWasmInitialized) {
31200 throw new Error("initializeWasm() must be awaited first!");
31202 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
31203 return nativeResponseValue;
31205 // void Sha256_free(struct LDKSha256 this_obj);
31207 export function Sha256_free(this_obj: number): void {
31208 if(!isWasmInitialized) {
31209 throw new Error("initializeWasm() must be awaited first!");
31211 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
31212 // debug statements here
31214 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
31216 export function Sha256_clone_ptr(arg: number): number {
31217 if(!isWasmInitialized) {
31218 throw new Error("initializeWasm() must be awaited first!");
31220 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
31221 return nativeResponseValue;
31223 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
31225 export function Sha256_clone(orig: number): number {
31226 if(!isWasmInitialized) {
31227 throw new Error("initializeWasm() must be awaited first!");
31229 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
31230 return nativeResponseValue;
31232 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
31234 export function Sha256_hash(o: number): bigint {
31235 if(!isWasmInitialized) {
31236 throw new Error("initializeWasm() must be awaited first!");
31238 const nativeResponseValue = wasm.TS_Sha256_hash(o);
31239 return nativeResponseValue;
31241 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
31243 export function Sha256_eq(a: number, b: number): boolean {
31244 if(!isWasmInitialized) {
31245 throw new Error("initializeWasm() must be awaited first!");
31247 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
31248 return nativeResponseValue;
31250 // void Description_free(struct LDKDescription this_obj);
31252 export function Description_free(this_obj: number): void {
31253 if(!isWasmInitialized) {
31254 throw new Error("initializeWasm() must be awaited first!");
31256 const nativeResponseValue = wasm.TS_Description_free(this_obj);
31257 // debug statements here
31259 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
31261 export function Description_clone_ptr(arg: number): number {
31262 if(!isWasmInitialized) {
31263 throw new Error("initializeWasm() must be awaited first!");
31265 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
31266 return nativeResponseValue;
31268 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
31270 export function Description_clone(orig: number): number {
31271 if(!isWasmInitialized) {
31272 throw new Error("initializeWasm() must be awaited first!");
31274 const nativeResponseValue = wasm.TS_Description_clone(orig);
31275 return nativeResponseValue;
31277 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
31279 export function Description_hash(o: number): bigint {
31280 if(!isWasmInitialized) {
31281 throw new Error("initializeWasm() must be awaited first!");
31283 const nativeResponseValue = wasm.TS_Description_hash(o);
31284 return nativeResponseValue;
31286 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
31288 export function Description_eq(a: number, b: number): boolean {
31289 if(!isWasmInitialized) {
31290 throw new Error("initializeWasm() must be awaited first!");
31292 const nativeResponseValue = wasm.TS_Description_eq(a, b);
31293 return nativeResponseValue;
31295 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
31297 export function PayeePubKey_free(this_obj: number): void {
31298 if(!isWasmInitialized) {
31299 throw new Error("initializeWasm() must be awaited first!");
31301 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
31302 // debug statements here
31304 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
31306 export function PayeePubKey_get_a(this_ptr: number): number {
31307 if(!isWasmInitialized) {
31308 throw new Error("initializeWasm() must be awaited first!");
31310 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
31311 return nativeResponseValue;
31313 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31315 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
31316 if(!isWasmInitialized) {
31317 throw new Error("initializeWasm() must be awaited first!");
31319 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
31320 // debug statements here
31322 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
31324 export function PayeePubKey_new(a_arg: number): number {
31325 if(!isWasmInitialized) {
31326 throw new Error("initializeWasm() must be awaited first!");
31328 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
31329 return nativeResponseValue;
31331 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
31333 export function PayeePubKey_clone_ptr(arg: number): number {
31334 if(!isWasmInitialized) {
31335 throw new Error("initializeWasm() must be awaited first!");
31337 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
31338 return nativeResponseValue;
31340 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
31342 export function PayeePubKey_clone(orig: number): number {
31343 if(!isWasmInitialized) {
31344 throw new Error("initializeWasm() must be awaited first!");
31346 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
31347 return nativeResponseValue;
31349 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
31351 export function PayeePubKey_hash(o: number): bigint {
31352 if(!isWasmInitialized) {
31353 throw new Error("initializeWasm() must be awaited first!");
31355 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
31356 return nativeResponseValue;
31358 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
31360 export function PayeePubKey_eq(a: number, b: number): boolean {
31361 if(!isWasmInitialized) {
31362 throw new Error("initializeWasm() must be awaited first!");
31364 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
31365 return nativeResponseValue;
31367 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
31369 export function ExpiryTime_free(this_obj: number): void {
31370 if(!isWasmInitialized) {
31371 throw new Error("initializeWasm() must be awaited first!");
31373 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
31374 // debug statements here
31376 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
31378 export function ExpiryTime_clone_ptr(arg: number): number {
31379 if(!isWasmInitialized) {
31380 throw new Error("initializeWasm() must be awaited first!");
31382 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
31383 return nativeResponseValue;
31385 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
31387 export function ExpiryTime_clone(orig: number): number {
31388 if(!isWasmInitialized) {
31389 throw new Error("initializeWasm() must be awaited first!");
31391 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
31392 return nativeResponseValue;
31394 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
31396 export function ExpiryTime_hash(o: number): bigint {
31397 if(!isWasmInitialized) {
31398 throw new Error("initializeWasm() must be awaited first!");
31400 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
31401 return nativeResponseValue;
31403 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
31405 export function ExpiryTime_eq(a: number, b: number): boolean {
31406 if(!isWasmInitialized) {
31407 throw new Error("initializeWasm() must be awaited first!");
31409 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
31410 return nativeResponseValue;
31412 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
31414 export function MinFinalCltvExpiry_free(this_obj: number): void {
31415 if(!isWasmInitialized) {
31416 throw new Error("initializeWasm() must be awaited first!");
31418 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
31419 // debug statements here
31421 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
31423 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
31424 if(!isWasmInitialized) {
31425 throw new Error("initializeWasm() must be awaited first!");
31427 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
31428 return nativeResponseValue;
31430 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
31432 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
31433 if(!isWasmInitialized) {
31434 throw new Error("initializeWasm() must be awaited first!");
31436 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
31437 // debug statements here
31439 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
31441 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
31442 if(!isWasmInitialized) {
31443 throw new Error("initializeWasm() must be awaited first!");
31445 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
31446 return nativeResponseValue;
31448 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
31450 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
31451 if(!isWasmInitialized) {
31452 throw new Error("initializeWasm() must be awaited first!");
31454 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
31455 return nativeResponseValue;
31457 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
31459 export function MinFinalCltvExpiry_clone(orig: number): number {
31460 if(!isWasmInitialized) {
31461 throw new Error("initializeWasm() must be awaited first!");
31463 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
31464 return nativeResponseValue;
31466 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
31468 export function MinFinalCltvExpiry_hash(o: number): bigint {
31469 if(!isWasmInitialized) {
31470 throw new Error("initializeWasm() must be awaited first!");
31472 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
31473 return nativeResponseValue;
31475 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
31477 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
31478 if(!isWasmInitialized) {
31479 throw new Error("initializeWasm() must be awaited first!");
31481 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
31482 return nativeResponseValue;
31484 // void Fallback_free(struct LDKFallback this_ptr);
31486 export function Fallback_free(this_ptr: number): void {
31487 if(!isWasmInitialized) {
31488 throw new Error("initializeWasm() must be awaited first!");
31490 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
31491 // debug statements here
31493 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
31495 export function Fallback_clone_ptr(arg: number): number {
31496 if(!isWasmInitialized) {
31497 throw new Error("initializeWasm() must be awaited first!");
31499 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
31500 return nativeResponseValue;
31502 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
31504 export function Fallback_clone(orig: number): number {
31505 if(!isWasmInitialized) {
31506 throw new Error("initializeWasm() must be awaited first!");
31508 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
31509 return nativeResponseValue;
31511 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
31513 export function Fallback_seg_wit_program(version: number, program: number): number {
31514 if(!isWasmInitialized) {
31515 throw new Error("initializeWasm() must be awaited first!");
31517 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
31518 return nativeResponseValue;
31520 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
31522 export function Fallback_pub_key_hash(a: number): number {
31523 if(!isWasmInitialized) {
31524 throw new Error("initializeWasm() must be awaited first!");
31526 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
31527 return nativeResponseValue;
31529 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
31531 export function Fallback_script_hash(a: number): number {
31532 if(!isWasmInitialized) {
31533 throw new Error("initializeWasm() must be awaited first!");
31535 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
31536 return nativeResponseValue;
31538 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
31540 export function Fallback_hash(o: number): bigint {
31541 if(!isWasmInitialized) {
31542 throw new Error("initializeWasm() must be awaited first!");
31544 const nativeResponseValue = wasm.TS_Fallback_hash(o);
31545 return nativeResponseValue;
31547 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
31549 export function Fallback_eq(a: number, b: number): boolean {
31550 if(!isWasmInitialized) {
31551 throw new Error("initializeWasm() must be awaited first!");
31553 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
31554 return nativeResponseValue;
31556 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
31558 export function InvoiceSignature_free(this_obj: number): void {
31559 if(!isWasmInitialized) {
31560 throw new Error("initializeWasm() must be awaited first!");
31562 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
31563 // debug statements here
31565 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
31567 export function InvoiceSignature_clone_ptr(arg: number): number {
31568 if(!isWasmInitialized) {
31569 throw new Error("initializeWasm() must be awaited first!");
31571 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
31572 return nativeResponseValue;
31574 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
31576 export function InvoiceSignature_clone(orig: number): number {
31577 if(!isWasmInitialized) {
31578 throw new Error("initializeWasm() must be awaited first!");
31580 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
31581 return nativeResponseValue;
31583 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
31585 export function InvoiceSignature_eq(a: number, b: number): boolean {
31586 if(!isWasmInitialized) {
31587 throw new Error("initializeWasm() must be awaited first!");
31589 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
31590 return nativeResponseValue;
31592 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
31594 export function PrivateRoute_free(this_obj: number): void {
31595 if(!isWasmInitialized) {
31596 throw new Error("initializeWasm() must be awaited first!");
31598 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
31599 // debug statements here
31601 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
31603 export function PrivateRoute_clone_ptr(arg: number): number {
31604 if(!isWasmInitialized) {
31605 throw new Error("initializeWasm() must be awaited first!");
31607 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
31608 return nativeResponseValue;
31610 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
31612 export function PrivateRoute_clone(orig: number): number {
31613 if(!isWasmInitialized) {
31614 throw new Error("initializeWasm() must be awaited first!");
31616 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
31617 return nativeResponseValue;
31619 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
31621 export function PrivateRoute_hash(o: number): bigint {
31622 if(!isWasmInitialized) {
31623 throw new Error("initializeWasm() must be awaited first!");
31625 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
31626 return nativeResponseValue;
31628 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
31630 export function PrivateRoute_eq(a: number, b: number): boolean {
31631 if(!isWasmInitialized) {
31632 throw new Error("initializeWasm() must be awaited first!");
31634 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
31635 return nativeResponseValue;
31637 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
31639 export function SignedRawInvoice_into_parts(this_arg: number): number {
31640 if(!isWasmInitialized) {
31641 throw new Error("initializeWasm() must be awaited first!");
31643 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
31644 return nativeResponseValue;
31646 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31648 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
31649 if(!isWasmInitialized) {
31650 throw new Error("initializeWasm() must be awaited first!");
31652 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
31653 return nativeResponseValue;
31655 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
31657 export function SignedRawInvoice_hash(this_arg: number): number {
31658 if(!isWasmInitialized) {
31659 throw new Error("initializeWasm() must be awaited first!");
31661 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
31662 return nativeResponseValue;
31664 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31666 export function SignedRawInvoice_signature(this_arg: number): number {
31667 if(!isWasmInitialized) {
31668 throw new Error("initializeWasm() must be awaited first!");
31670 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
31671 return nativeResponseValue;
31673 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31675 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
31676 if(!isWasmInitialized) {
31677 throw new Error("initializeWasm() must be awaited first!");
31679 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
31680 return nativeResponseValue;
31682 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31684 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
31685 if(!isWasmInitialized) {
31686 throw new Error("initializeWasm() must be awaited first!");
31688 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
31689 return nativeResponseValue;
31691 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31693 export function RawInvoice_hash(this_arg: number): number {
31694 if(!isWasmInitialized) {
31695 throw new Error("initializeWasm() must be awaited first!");
31697 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
31698 return nativeResponseValue;
31700 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31702 export function RawInvoice_payment_hash(this_arg: number): number {
31703 if(!isWasmInitialized) {
31704 throw new Error("initializeWasm() must be awaited first!");
31706 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
31707 return nativeResponseValue;
31709 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31711 export function RawInvoice_description(this_arg: number): number {
31712 if(!isWasmInitialized) {
31713 throw new Error("initializeWasm() must be awaited first!");
31715 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
31716 return nativeResponseValue;
31718 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31720 export function RawInvoice_payee_pub_key(this_arg: number): number {
31721 if(!isWasmInitialized) {
31722 throw new Error("initializeWasm() must be awaited first!");
31724 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
31725 return nativeResponseValue;
31727 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31729 export function RawInvoice_description_hash(this_arg: number): number {
31730 if(!isWasmInitialized) {
31731 throw new Error("initializeWasm() must be awaited first!");
31733 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
31734 return nativeResponseValue;
31736 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31738 export function RawInvoice_expiry_time(this_arg: number): number {
31739 if(!isWasmInitialized) {
31740 throw new Error("initializeWasm() must be awaited first!");
31742 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
31743 return nativeResponseValue;
31745 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31747 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
31748 if(!isWasmInitialized) {
31749 throw new Error("initializeWasm() must be awaited first!");
31751 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
31752 return nativeResponseValue;
31754 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31756 export function RawInvoice_payment_secret(this_arg: number): number {
31757 if(!isWasmInitialized) {
31758 throw new Error("initializeWasm() must be awaited first!");
31760 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
31761 return nativeResponseValue;
31763 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31765 export function RawInvoice_features(this_arg: number): number {
31766 if(!isWasmInitialized) {
31767 throw new Error("initializeWasm() must be awaited first!");
31769 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
31770 return nativeResponseValue;
31772 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31774 export function RawInvoice_private_routes(this_arg: number): number {
31775 if(!isWasmInitialized) {
31776 throw new Error("initializeWasm() must be awaited first!");
31778 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
31779 return nativeResponseValue;
31781 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31783 export function RawInvoice_amount_pico_btc(this_arg: number): number {
31784 if(!isWasmInitialized) {
31785 throw new Error("initializeWasm() must be awaited first!");
31787 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
31788 return nativeResponseValue;
31790 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31792 export function RawInvoice_currency(this_arg: number): Currency {
31793 if(!isWasmInitialized) {
31794 throw new Error("initializeWasm() must be awaited first!");
31796 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
31797 return nativeResponseValue;
31799 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
31801 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
31802 if(!isWasmInitialized) {
31803 throw new Error("initializeWasm() must be awaited first!");
31805 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
31806 return nativeResponseValue;
31808 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
31810 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
31811 if(!isWasmInitialized) {
31812 throw new Error("initializeWasm() must be awaited first!");
31814 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
31815 return nativeResponseValue;
31817 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
31819 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
31820 if(!isWasmInitialized) {
31821 throw new Error("initializeWasm() must be awaited first!");
31823 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
31824 return nativeResponseValue;
31826 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
31828 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
31829 if(!isWasmInitialized) {
31830 throw new Error("initializeWasm() must be awaited first!");
31832 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
31833 return nativeResponseValue;
31835 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
31837 export function Invoice_into_signed_raw(this_arg: number): number {
31838 if(!isWasmInitialized) {
31839 throw new Error("initializeWasm() must be awaited first!");
31841 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
31842 return nativeResponseValue;
31844 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
31846 export function Invoice_check_signature(this_arg: number): number {
31847 if(!isWasmInitialized) {
31848 throw new Error("initializeWasm() must be awaited first!");
31850 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
31851 return nativeResponseValue;
31853 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
31855 export function Invoice_from_signed(signed_invoice: number): number {
31856 if(!isWasmInitialized) {
31857 throw new Error("initializeWasm() must be awaited first!");
31859 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
31860 return nativeResponseValue;
31862 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
31864 export function Invoice_duration_since_epoch(this_arg: number): bigint {
31865 if(!isWasmInitialized) {
31866 throw new Error("initializeWasm() must be awaited first!");
31868 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
31869 return nativeResponseValue;
31871 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
31873 export function Invoice_payment_hash(this_arg: number): number {
31874 if(!isWasmInitialized) {
31875 throw new Error("initializeWasm() must be awaited first!");
31877 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
31878 return nativeResponseValue;
31880 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
31882 export function Invoice_payee_pub_key(this_arg: number): number {
31883 if(!isWasmInitialized) {
31884 throw new Error("initializeWasm() must be awaited first!");
31886 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
31887 return nativeResponseValue;
31889 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
31891 export function Invoice_payment_secret(this_arg: number): number {
31892 if(!isWasmInitialized) {
31893 throw new Error("initializeWasm() must be awaited first!");
31895 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
31896 return nativeResponseValue;
31898 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
31900 export function Invoice_features(this_arg: number): number {
31901 if(!isWasmInitialized) {
31902 throw new Error("initializeWasm() must be awaited first!");
31904 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
31905 return nativeResponseValue;
31907 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
31909 export function Invoice_recover_payee_pub_key(this_arg: number): number {
31910 if(!isWasmInitialized) {
31911 throw new Error("initializeWasm() must be awaited first!");
31913 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
31914 return nativeResponseValue;
31916 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
31918 export function Invoice_expiry_time(this_arg: number): bigint {
31919 if(!isWasmInitialized) {
31920 throw new Error("initializeWasm() must be awaited first!");
31922 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
31923 return nativeResponseValue;
31925 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
31927 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
31928 if(!isWasmInitialized) {
31929 throw new Error("initializeWasm() must be awaited first!");
31931 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
31932 return nativeResponseValue;
31934 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
31936 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
31937 if(!isWasmInitialized) {
31938 throw new Error("initializeWasm() must be awaited first!");
31940 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
31941 return nativeResponseValue;
31943 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
31945 export function Invoice_private_routes(this_arg: number): number {
31946 if(!isWasmInitialized) {
31947 throw new Error("initializeWasm() must be awaited first!");
31949 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
31950 return nativeResponseValue;
31952 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
31954 export function Invoice_route_hints(this_arg: number): number {
31955 if(!isWasmInitialized) {
31956 throw new Error("initializeWasm() must be awaited first!");
31958 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
31959 return nativeResponseValue;
31961 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
31963 export function Invoice_currency(this_arg: number): Currency {
31964 if(!isWasmInitialized) {
31965 throw new Error("initializeWasm() must be awaited first!");
31967 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
31968 return nativeResponseValue;
31970 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
31972 export function Invoice_amount_milli_satoshis(this_arg: number): number {
31973 if(!isWasmInitialized) {
31974 throw new Error("initializeWasm() must be awaited first!");
31976 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
31977 return nativeResponseValue;
31979 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
31981 export function Description_new(description: number): number {
31982 if(!isWasmInitialized) {
31983 throw new Error("initializeWasm() must be awaited first!");
31985 const nativeResponseValue = wasm.TS_Description_new(description);
31986 return nativeResponseValue;
31988 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
31990 export function Description_into_inner(this_arg: number): number {
31991 if(!isWasmInitialized) {
31992 throw new Error("initializeWasm() must be awaited first!");
31994 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
31995 return nativeResponseValue;
31997 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
31999 export function ExpiryTime_from_seconds(seconds: bigint): number {
32000 if(!isWasmInitialized) {
32001 throw new Error("initializeWasm() must be awaited first!");
32003 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
32004 return nativeResponseValue;
32006 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
32008 export function ExpiryTime_from_duration(duration: bigint): number {
32009 if(!isWasmInitialized) {
32010 throw new Error("initializeWasm() must be awaited first!");
32012 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
32013 return nativeResponseValue;
32015 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32017 export function ExpiryTime_as_seconds(this_arg: number): bigint {
32018 if(!isWasmInitialized) {
32019 throw new Error("initializeWasm() must be awaited first!");
32021 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
32022 return nativeResponseValue;
32024 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32026 export function ExpiryTime_as_duration(this_arg: number): bigint {
32027 if(!isWasmInitialized) {
32028 throw new Error("initializeWasm() must be awaited first!");
32030 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
32031 return nativeResponseValue;
32033 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
32035 export function PrivateRoute_new(hops: number): number {
32036 if(!isWasmInitialized) {
32037 throw new Error("initializeWasm() must be awaited first!");
32039 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
32040 return nativeResponseValue;
32042 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
32044 export function PrivateRoute_into_inner(this_arg: number): number {
32045 if(!isWasmInitialized) {
32046 throw new Error("initializeWasm() must be awaited first!");
32048 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
32049 return nativeResponseValue;
32051 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
32053 export function CreationError_clone(orig: number): CreationError {
32054 if(!isWasmInitialized) {
32055 throw new Error("initializeWasm() must be awaited first!");
32057 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
32058 return nativeResponseValue;
32060 // enum LDKCreationError CreationError_description_too_long(void);
32062 export function CreationError_description_too_long(): CreationError {
32063 if(!isWasmInitialized) {
32064 throw new Error("initializeWasm() must be awaited first!");
32066 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
32067 return nativeResponseValue;
32069 // enum LDKCreationError CreationError_route_too_long(void);
32071 export function CreationError_route_too_long(): CreationError {
32072 if(!isWasmInitialized) {
32073 throw new Error("initializeWasm() must be awaited first!");
32075 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
32076 return nativeResponseValue;
32078 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
32080 export function CreationError_timestamp_out_of_bounds(): CreationError {
32081 if(!isWasmInitialized) {
32082 throw new Error("initializeWasm() must be awaited first!");
32084 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
32085 return nativeResponseValue;
32087 // enum LDKCreationError CreationError_invalid_amount(void);
32089 export function CreationError_invalid_amount(): CreationError {
32090 if(!isWasmInitialized) {
32091 throw new Error("initializeWasm() must be awaited first!");
32093 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
32094 return nativeResponseValue;
32096 // enum LDKCreationError CreationError_missing_route_hints(void);
32098 export function CreationError_missing_route_hints(): CreationError {
32099 if(!isWasmInitialized) {
32100 throw new Error("initializeWasm() must be awaited first!");
32102 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
32103 return nativeResponseValue;
32105 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
32107 export function CreationError_eq(a: number, b: number): boolean {
32108 if(!isWasmInitialized) {
32109 throw new Error("initializeWasm() must be awaited first!");
32111 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
32112 return nativeResponseValue;
32114 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
32116 export function CreationError_to_str(o: number): number {
32117 if(!isWasmInitialized) {
32118 throw new Error("initializeWasm() must be awaited first!");
32120 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
32121 return nativeResponseValue;
32123 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
32125 export function SemanticError_clone(orig: number): SemanticError {
32126 if(!isWasmInitialized) {
32127 throw new Error("initializeWasm() must be awaited first!");
32129 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
32130 return nativeResponseValue;
32132 // enum LDKSemanticError SemanticError_no_payment_hash(void);
32134 export function SemanticError_no_payment_hash(): SemanticError {
32135 if(!isWasmInitialized) {
32136 throw new Error("initializeWasm() must be awaited first!");
32138 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
32139 return nativeResponseValue;
32141 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
32143 export function SemanticError_multiple_payment_hashes(): SemanticError {
32144 if(!isWasmInitialized) {
32145 throw new Error("initializeWasm() must be awaited first!");
32147 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
32148 return nativeResponseValue;
32150 // enum LDKSemanticError SemanticError_no_description(void);
32152 export function SemanticError_no_description(): SemanticError {
32153 if(!isWasmInitialized) {
32154 throw new Error("initializeWasm() must be awaited first!");
32156 const nativeResponseValue = wasm.TS_SemanticError_no_description();
32157 return nativeResponseValue;
32159 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
32161 export function SemanticError_multiple_descriptions(): SemanticError {
32162 if(!isWasmInitialized) {
32163 throw new Error("initializeWasm() must be awaited first!");
32165 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
32166 return nativeResponseValue;
32168 // enum LDKSemanticError SemanticError_no_payment_secret(void);
32170 export function SemanticError_no_payment_secret(): SemanticError {
32171 if(!isWasmInitialized) {
32172 throw new Error("initializeWasm() must be awaited first!");
32174 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
32175 return nativeResponseValue;
32177 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
32179 export function SemanticError_multiple_payment_secrets(): SemanticError {
32180 if(!isWasmInitialized) {
32181 throw new Error("initializeWasm() must be awaited first!");
32183 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
32184 return nativeResponseValue;
32186 // enum LDKSemanticError SemanticError_invalid_features(void);
32188 export function SemanticError_invalid_features(): SemanticError {
32189 if(!isWasmInitialized) {
32190 throw new Error("initializeWasm() must be awaited first!");
32192 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
32193 return nativeResponseValue;
32195 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
32197 export function SemanticError_invalid_recovery_id(): SemanticError {
32198 if(!isWasmInitialized) {
32199 throw new Error("initializeWasm() must be awaited first!");
32201 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
32202 return nativeResponseValue;
32204 // enum LDKSemanticError SemanticError_invalid_signature(void);
32206 export function SemanticError_invalid_signature(): SemanticError {
32207 if(!isWasmInitialized) {
32208 throw new Error("initializeWasm() must be awaited first!");
32210 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
32211 return nativeResponseValue;
32213 // enum LDKSemanticError SemanticError_imprecise_amount(void);
32215 export function SemanticError_imprecise_amount(): SemanticError {
32216 if(!isWasmInitialized) {
32217 throw new Error("initializeWasm() must be awaited first!");
32219 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
32220 return nativeResponseValue;
32222 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
32224 export function SemanticError_eq(a: number, b: number): boolean {
32225 if(!isWasmInitialized) {
32226 throw new Error("initializeWasm() must be awaited first!");
32228 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
32229 return nativeResponseValue;
32231 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
32233 export function SemanticError_to_str(o: number): number {
32234 if(!isWasmInitialized) {
32235 throw new Error("initializeWasm() must be awaited first!");
32237 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
32238 return nativeResponseValue;
32240 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
32242 export function SignOrCreationError_free(this_ptr: number): void {
32243 if(!isWasmInitialized) {
32244 throw new Error("initializeWasm() must be awaited first!");
32246 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
32247 // debug statements here
32249 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
32251 export function SignOrCreationError_clone_ptr(arg: number): number {
32252 if(!isWasmInitialized) {
32253 throw new Error("initializeWasm() must be awaited first!");
32255 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
32256 return nativeResponseValue;
32258 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
32260 export function SignOrCreationError_clone(orig: number): number {
32261 if(!isWasmInitialized) {
32262 throw new Error("initializeWasm() must be awaited first!");
32264 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
32265 return nativeResponseValue;
32267 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
32269 export function SignOrCreationError_sign_error(): number {
32270 if(!isWasmInitialized) {
32271 throw new Error("initializeWasm() must be awaited first!");
32273 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
32274 return nativeResponseValue;
32276 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
32278 export function SignOrCreationError_creation_error(a: CreationError): number {
32279 if(!isWasmInitialized) {
32280 throw new Error("initializeWasm() must be awaited first!");
32282 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
32283 return nativeResponseValue;
32285 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
32287 export function SignOrCreationError_eq(a: number, b: number): boolean {
32288 if(!isWasmInitialized) {
32289 throw new Error("initializeWasm() must be awaited first!");
32291 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
32292 return nativeResponseValue;
32294 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
32296 export function SignOrCreationError_to_str(o: number): number {
32297 if(!isWasmInitialized) {
32298 throw new Error("initializeWasm() must be awaited first!");
32300 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
32301 return nativeResponseValue;
32303 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
32305 export function InvoicePayer_free(this_obj: number): void {
32306 if(!isWasmInitialized) {
32307 throw new Error("initializeWasm() must be awaited first!");
32309 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
32310 // debug statements here
32312 // void Payer_free(struct LDKPayer this_ptr);
32314 export function Payer_free(this_ptr: number): void {
32315 if(!isWasmInitialized) {
32316 throw new Error("initializeWasm() must be awaited first!");
32318 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
32319 // debug statements here
32321 // void Router_free(struct LDKRouter this_ptr);
32323 export function Router_free(this_ptr: number): void {
32324 if(!isWasmInitialized) {
32325 throw new Error("initializeWasm() must be awaited first!");
32327 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
32328 // debug statements here
32330 // void Retry_free(struct LDKRetry this_ptr);
32332 export function Retry_free(this_ptr: number): void {
32333 if(!isWasmInitialized) {
32334 throw new Error("initializeWasm() must be awaited first!");
32336 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
32337 // debug statements here
32339 // uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
32341 export function Retry_clone_ptr(arg: number): number {
32342 if(!isWasmInitialized) {
32343 throw new Error("initializeWasm() must be awaited first!");
32345 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
32346 return nativeResponseValue;
32348 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
32350 export function Retry_clone(orig: number): number {
32351 if(!isWasmInitialized) {
32352 throw new Error("initializeWasm() must be awaited first!");
32354 const nativeResponseValue = wasm.TS_Retry_clone(orig);
32355 return nativeResponseValue;
32357 // struct LDKRetry Retry_attempts(uintptr_t a);
32359 export function Retry_attempts(a: number): number {
32360 if(!isWasmInitialized) {
32361 throw new Error("initializeWasm() must be awaited first!");
32363 const nativeResponseValue = wasm.TS_Retry_attempts(a);
32364 return nativeResponseValue;
32366 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
32368 export function Retry_eq(a: number, b: number): boolean {
32369 if(!isWasmInitialized) {
32370 throw new Error("initializeWasm() must be awaited first!");
32372 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
32373 return nativeResponseValue;
32375 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
32377 export function Retry_hash(o: number): bigint {
32378 if(!isWasmInitialized) {
32379 throw new Error("initializeWasm() must be awaited first!");
32381 const nativeResponseValue = wasm.TS_Retry_hash(o);
32382 return nativeResponseValue;
32384 // void PaymentError_free(struct LDKPaymentError this_ptr);
32386 export function PaymentError_free(this_ptr: number): void {
32387 if(!isWasmInitialized) {
32388 throw new Error("initializeWasm() must be awaited first!");
32390 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
32391 // debug statements here
32393 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
32395 export function PaymentError_clone_ptr(arg: number): number {
32396 if(!isWasmInitialized) {
32397 throw new Error("initializeWasm() must be awaited first!");
32399 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
32400 return nativeResponseValue;
32402 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
32404 export function PaymentError_clone(orig: number): number {
32405 if(!isWasmInitialized) {
32406 throw new Error("initializeWasm() must be awaited first!");
32408 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
32409 return nativeResponseValue;
32411 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
32413 export function PaymentError_invoice(a: number): number {
32414 if(!isWasmInitialized) {
32415 throw new Error("initializeWasm() must be awaited first!");
32417 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
32418 return nativeResponseValue;
32420 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
32422 export function PaymentError_routing(a: number): number {
32423 if(!isWasmInitialized) {
32424 throw new Error("initializeWasm() must be awaited first!");
32426 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
32427 return nativeResponseValue;
32429 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
32431 export function PaymentError_sending(a: number): number {
32432 if(!isWasmInitialized) {
32433 throw new Error("initializeWasm() must be awaited first!");
32435 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
32436 return nativeResponseValue;
32438 // MUST_USE_RES struct LDKInvoicePayer InvoicePayer_new(struct LDKPayer payer, struct LDKRouter router, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer, struct LDKLogger logger, struct LDKEventHandler event_handler, struct LDKRetry retry);
32440 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry: number): number {
32441 if(!isWasmInitialized) {
32442 throw new Error("initializeWasm() must be awaited first!");
32444 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
32445 return nativeResponseValue;
32447 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
32449 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
32450 if(!isWasmInitialized) {
32451 throw new Error("initializeWasm() must be awaited first!");
32453 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
32454 return nativeResponseValue;
32456 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_zero_value_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice, uint64_t amount_msats);
32458 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
32459 if(!isWasmInitialized) {
32460 throw new Error("initializeWasm() must be awaited first!");
32462 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
32463 return nativeResponseValue;
32465 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_pubkey(const struct LDKInvoicePayer *NONNULL_PTR this_arg, struct LDKPublicKey pubkey, struct LDKThirtyTwoBytes payment_preimage, uint64_t amount_msats, uint32_t final_cltv_expiry_delta);
32467 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
32468 if(!isWasmInitialized) {
32469 throw new Error("initializeWasm() must be awaited first!");
32471 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
32472 return nativeResponseValue;
32474 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
32476 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
32477 if(!isWasmInitialized) {
32478 throw new Error("initializeWasm() must be awaited first!");
32480 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
32481 // debug statements here
32483 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
32485 export function InvoicePayer_as_EventHandler(this_arg: number): number {
32486 if(!isWasmInitialized) {
32487 throw new Error("initializeWasm() must be awaited first!");
32489 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
32490 return nativeResponseValue;
32492 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKSha256 description_hash, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
32494 export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: number, keys_manager: number, network: Currency, amt_msat: number, description_hash: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): number {
32495 if(!isWasmInitialized) {
32496 throw new Error("initializeWasm() must be awaited first!");
32498 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs);
32499 return nativeResponseValue;
32501 // struct LDKCResult_InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKKeysInterface keys_manager, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs);
32503 export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: number, keys_manager: number, network: Currency, amt_msat: number, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number): number {
32504 if(!isWasmInitialized) {
32505 throw new Error("initializeWasm() must be awaited first!");
32507 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs);
32508 return nativeResponseValue;
32510 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
32512 export function DefaultRouter_free(this_obj: number): void {
32513 if(!isWasmInitialized) {
32514 throw new Error("initializeWasm() must be awaited first!");
32516 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
32517 // debug statements here
32519 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
32521 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
32522 if(!isWasmInitialized) {
32523 throw new Error("initializeWasm() must be awaited first!");
32525 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
32526 return nativeResponseValue;
32528 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
32530 export function DefaultRouter_as_Router(this_arg: number): number {
32531 if(!isWasmInitialized) {
32532 throw new Error("initializeWasm() must be awaited first!");
32534 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
32535 return nativeResponseValue;
32537 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
32539 export function ChannelManager_as_Payer(this_arg: number): number {
32540 if(!isWasmInitialized) {
32541 throw new Error("initializeWasm() must be awaited first!");
32543 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
32544 return nativeResponseValue;
32546 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
32548 export function SiPrefix_from_str(s: number): number {
32549 if(!isWasmInitialized) {
32550 throw new Error("initializeWasm() must be awaited first!");
32552 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
32553 return nativeResponseValue;
32555 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
32557 export function Invoice_from_str(s: number): number {
32558 if(!isWasmInitialized) {
32559 throw new Error("initializeWasm() must be awaited first!");
32561 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
32562 return nativeResponseValue;
32564 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
32566 export function SignedRawInvoice_from_str(s: number): number {
32567 if(!isWasmInitialized) {
32568 throw new Error("initializeWasm() must be awaited first!");
32570 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
32571 return nativeResponseValue;
32573 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
32575 export function ParseError_to_str(o: number): number {
32576 if(!isWasmInitialized) {
32577 throw new Error("initializeWasm() must be awaited first!");
32579 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
32580 return nativeResponseValue;
32582 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
32584 export function ParseOrSemanticError_to_str(o: number): number {
32585 if(!isWasmInitialized) {
32586 throw new Error("initializeWasm() must be awaited first!");
32588 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
32589 return nativeResponseValue;
32591 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
32593 export function Invoice_to_str(o: number): number {
32594 if(!isWasmInitialized) {
32595 throw new Error("initializeWasm() must be awaited first!");
32597 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
32598 return nativeResponseValue;
32600 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
32602 export function SignedRawInvoice_to_str(o: number): number {
32603 if(!isWasmInitialized) {
32604 throw new Error("initializeWasm() must be awaited first!");
32606 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
32607 return nativeResponseValue;
32609 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
32611 export function Currency_to_str(o: number): number {
32612 if(!isWasmInitialized) {
32613 throw new Error("initializeWasm() must be awaited first!");
32615 const nativeResponseValue = wasm.TS_Currency_to_str(o);
32616 return nativeResponseValue;
32618 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
32620 export function SiPrefix_to_str(o: number): number {
32621 if(!isWasmInitialized) {
32622 throw new Error("initializeWasm() must be awaited first!");
32624 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
32625 return nativeResponseValue;
32629 js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2: bigint|number, arg3: bigint|number, arg4: bigint|number, arg5: bigint|number, arg6: bigint|number, arg7: bigint|number, arg8: bigint|number, arg9: bigint|number, arg10: bigint|number) {
32630 const weak: WeakRef<object> = js_objs[obj_ptr];
32631 if (weak == null || weak == undefined) {
32632 console.error("Got function call on unknown/free'd JS object!");
32633 throw new Error("Got function call on unknown/free'd JS object!");
32635 const obj: object = weak.deref();
32636 if (obj == null || obj == undefined) {
32637 console.error("Got function call on GC'd JS object!");
32638 throw new Error("Got function call on GC'd JS object!");
32642 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
32643 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
32644 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
32645 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
32646 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
32647 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
32648 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
32649 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
32650 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
32651 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
32652 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
32653 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
32654 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
32655 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
32656 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
32657 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
32658 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
32659 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
32660 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
32661 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
32662 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
32663 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
32664 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
32665 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
32666 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
32667 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
32668 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
32669 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
32670 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
32671 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
32672 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
32673 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
32674 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
32675 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
32676 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
32677 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
32678 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
32679 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
32680 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
32681 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
32682 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
32683 case 41: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
32684 case 42: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
32685 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
32686 case 44: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
32687 case 45: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
32688 case 46: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
32689 case 47: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
32690 case 48: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
32691 case 49: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
32692 case 50: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
32693 case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
32694 case 52: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
32695 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
32696 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
32697 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
32698 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
32699 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
32700 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
32701 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
32702 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
32703 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
32704 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
32705 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
32706 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
32707 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
32708 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
32709 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
32710 case 68: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
32711 case 69: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
32712 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
32713 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
32714 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
32715 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
32716 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
32717 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
32718 case 76: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
32719 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
32720 case 78: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
32721 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
32722 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
32723 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
32724 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
32725 case 83: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
32726 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
32727 case 85: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
32728 case 86: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
32729 case 87: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
32730 case 88: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
32731 case 89: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
32732 case 90: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
32733 case 91: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
32734 case 92: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
32735 case 93: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
32736 case 94: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
32737 case 95: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
32738 case 96: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
32739 case 97: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
32741 console.error("Got unknown function call from C!");
32742 throw new Error("Got unknown function call from C!");
32744 if (fn == null || fn == undefined) {
32745 console.error("Got function call on incorrect JS object!");
32746 throw new Error("Got function call on incorrect JS object!");
32748 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
32749 if (ret === undefined || ret === null) return BigInt(0);
32750 return BigInt(ret);