2 import * as version from './version.mjs';
3 import { UInt5 } 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 failes 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"] = js_invoke;
92 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
93 await finishInitializeWasm(wasmInstance);
97 export async function initializeWasmFetch(uri: string) {
98 const stream = fetch(uri);
99 imports.env["js_invoke_function"] = js_invoke;
100 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
101 await finishInitializeWasm(wasmInstance);
106 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
107 const arr = new Uint8Array(inputArray.length);
108 for (var i = 0; i < inputArray.length; i++) {
109 arr[i] = inputArray[i].getVal();
115 export function encodeUint8Array (inputArray: Uint8Array): number {
116 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
117 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
118 arrayLengthView[0] = inputArray.length;
119 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
120 arrayMemoryView.set(inputArray);
121 return cArrayPointer;
124 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
125 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
126 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
127 arrayMemoryView.set(inputArray, 1);
128 arrayMemoryView[0] = inputArray.length;
129 return cArrayPointer;
132 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
133 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
134 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
135 arrayLengthView[0] = inputArray.length;
136 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
137 arrayMemoryView.set(inputArray);
138 return cArrayPointer;
142 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
143 if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
148 export function getArrayLength(arrayPointer: number): number {
149 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
150 return arraySizeViewer[0];
153 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
154 const arraySize = getArrayLength(arrayPointer);
155 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
156 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
157 // will free the underlying memory when it becomes unreachable instead of copying here.
158 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
159 const actualArray = actualArrayViewer.slice(0, arraySize);
161 wasm.TS_free(arrayPointer);
165 const decodeUint32Array = (arrayPointer: number, free = true) => {
166 const arraySize = getArrayLength(arrayPointer);
167 const actualArrayViewer = new Uint32Array(
168 wasm.memory.buffer, // value
169 arrayPointer + 4, // offset (ignoring length bytes)
170 arraySize // uint32 count
172 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
173 // will free the underlying memory when it becomes unreachable instead of copying here.
174 const actualArray = actualArrayViewer.slice(0, arraySize);
176 wasm.TS_free(arrayPointer);
182 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
185 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
186 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
187 return actualArrayViewer[idx];
191 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
192 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
193 return actualArrayViewer[idx];
198 export function encodeString(str: string): number {
199 const charArray = new TextEncoder().encode(str);
200 return encodeUint8Array(charArray);
204 export function decodeString(stringPointer: number, free = true): string {
205 const arraySize = getArrayLength(stringPointer);
206 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
207 const result = new TextDecoder("utf-8").decode(memoryView);
210 wasm.TS_free(stringPointer);
216 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
217 /* @internal */ export function debugPrintRemainingAllocs() { }
220 export enum AccessError {
222 * The requested chain is unknown.
224 LDKAccessError_UnknownChain,
226 * The requested transaction doesn't exist or hasn't confirmed.
228 LDKAccessError_UnknownTx,
233 export enum COption_NoneZ {
235 * When we're in this state, this COption_NoneZ contains a
237 LDKCOption_NoneZ_Some,
239 * When we're in this state, this COption_NoneZ contains nothing
241 LDKCOption_NoneZ_None,
246 export enum ChannelMonitorUpdateErr {
248 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
249 our state failed, but is expected to succeed at some point in the future).
251 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
252 submitting new commitment transactions to the counterparty. Once the update(s) that failed
253 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
254 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
257 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
258 you return a TemporaryFailure you must ensure that it is written to disk safely before
259 writing out the latest ChannelManager state.
261 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
262 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
263 to claim it on this channel) and those updates must be applied wherever they can be. At
264 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
265 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
266 the channel which would invalidate previous ChannelMonitors are not made when a channel has
269 Note that even if updates made after TemporaryFailure succeed you must still provide a
270 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
271 normal channel operation. Note that this is normally generated through a call to
272 [`ChainMonitor::channel_monitor_updated`].
274 Note that the update being processed here will not be replayed for you when you return a
275 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
276 you must store the update itself on your own local disk prior to returning a
277 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
278 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
281 For deployments where a copy of ChannelMonitors and other local state are backed up in a
282 remote location (with local copies persisted immediately), it is anticipated that all
283 updates will return TemporaryFailure until the remote copies could be updated.
285 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
287 LDKChannelMonitorUpdateErr_TemporaryFailure,
289 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
290 different watchtower and cannot update with all watchtowers that were previously informed
293 At reception of this error, ChannelManager will force-close the channel and return at
294 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
295 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
296 update must be rejected.
298 This failure may also signal a failure to update the local persisted copy of one of
299 the channel monitor instance.
301 Note that even when you fail a holder commitment transaction update, you must store the
302 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
303 broadcasts it (e.g distributed channel-monitor deployment)
305 In case of distributed watchtowers deployment, the new version must be written to disk, as
306 state may have been stored but rejected due to a block forcing a commitment broadcast. This
307 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
308 lagging behind on block processing.
310 LDKChannelMonitorUpdateErr_PermanentFailure,
315 export enum ConfirmationTarget {
317 * We are happy with this transaction confirming slowly when feerate drops some.
319 LDKConfirmationTarget_Background,
321 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
323 LDKConfirmationTarget_Normal,
325 * We'd like this transaction to confirm in the next few blocks.
327 LDKConfirmationTarget_HighPriority,
332 export enum CreationError {
334 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
336 LDKCreationError_DescriptionTooLong,
338 * The specified route has too many hops and can't be encoded
340 LDKCreationError_RouteTooLong,
342 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
344 LDKCreationError_TimestampOutOfBounds,
346 * The supplied millisatoshi amount was greater than the total bitcoin supply.
348 LDKCreationError_InvalidAmount,
350 * Route hints were required for this invoice and were missing. Applies to
353 [phantom invoices]: crate::utils::create_phantom_invoice
355 LDKCreationError_MissingRouteHints,
360 export enum Currency {
368 LDKCurrency_BitcoinTestnet,
387 * Designates extremely verbose information, including gossip-induced messages
391 * Designates very low priority, often extremely verbose, information
395 * Designates lower priority information
399 * Designates useful information
403 * Designates hazardous situations
407 * Designates very serious errors
414 export enum Network {
416 * The main Bitcoin blockchain.
420 * The testnet3 blockchain.
424 * A local test blockchain.
428 * A blockchain on which blocks are signed instead of mined.
435 export enum Recipient {
437 * The invoice should be signed with the local node secret key.
441 * The invoice should be signed with the phantom node secret key. This secret key must be the
442 same for all nodes participating in the [phantom node payment].
444 [phantom node payment]: PhantomKeysManager
446 LDKRecipient_PhantomNode,
451 export enum Secp256k1Error {
453 * Signature failed verification
455 LDKSecp256k1Error_IncorrectSignature,
457 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
459 LDKSecp256k1Error_InvalidMessage,
463 LDKSecp256k1Error_InvalidPublicKey,
467 LDKSecp256k1Error_InvalidSignature,
471 LDKSecp256k1Error_InvalidSecretKey,
475 LDKSecp256k1Error_InvalidRecoveryId,
477 * Invalid tweak for add_assign or mul_assign
479 LDKSecp256k1Error_InvalidTweak,
481 * tweak_add_check failed on an xonly public key
483 LDKSecp256k1Error_TweakCheckFailed,
485 * Didn't pass enough memory to context creation with preallocated memory
487 LDKSecp256k1Error_NotEnoughMemory,
492 export enum SemanticError {
494 * The invoice is missing the mandatory payment hash
496 LDKSemanticError_NoPaymentHash,
498 * The invoice has multiple payment hashes which isn't allowed
500 LDKSemanticError_MultiplePaymentHashes,
502 * No description or description hash are part of the invoice
504 LDKSemanticError_NoDescription,
506 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
508 LDKSemanticError_MultipleDescriptions,
510 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
513 LDKSemanticError_NoPaymentSecret,
515 * The invoice contains multiple payment secrets
517 LDKSemanticError_MultiplePaymentSecrets,
519 * The invoice's features are invalid
521 LDKSemanticError_InvalidFeatures,
523 * The recovery id doesn't fit the signature/pub key
525 LDKSemanticError_InvalidRecoveryId,
527 * The invoice's signature is invalid
529 LDKSemanticError_InvalidSignature,
531 * The invoice's amount was not a whole number of millisatoshis
533 LDKSemanticError_ImpreciseAmount,
538 export enum SiPrefix {
558 export class LDKBech32Error {
559 protected constructor() {}
562 export function LDKBech32Error_ty_from_ptr(ptr: number): number {
563 if(!isWasmInitialized) {
564 throw new Error("initializeWasm() must be awaited first!");
566 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
567 return nativeResponseValue;
570 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: number): number {
571 if(!isWasmInitialized) {
572 throw new Error("initializeWasm() must be awaited first!");
574 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
575 return nativeResponseValue;
578 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: number): number {
579 if(!isWasmInitialized) {
580 throw new Error("initializeWasm() must be awaited first!");
582 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
583 return nativeResponseValue;
585 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
587 export function TxOut_get_script_pubkey(thing: number): number {
588 if(!isWasmInitialized) {
589 throw new Error("initializeWasm() must be awaited first!");
591 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
592 return nativeResponseValue;
594 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
596 export function TxOut_get_value(thing: number): bigint {
597 if(!isWasmInitialized) {
598 throw new Error("initializeWasm() must be awaited first!");
600 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
601 return nativeResponseValue;
603 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
605 export function CResult_NoneNoneZ_get_ok(owner: number): void {
606 if(!isWasmInitialized) {
607 throw new Error("initializeWasm() must be awaited first!");
609 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
610 // debug statements here
612 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
614 export function CResult_NoneNoneZ_get_err(owner: number): void {
615 if(!isWasmInitialized) {
616 throw new Error("initializeWasm() must be awaited first!");
618 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
619 // debug statements here
621 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
623 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
624 if(!isWasmInitialized) {
625 throw new Error("initializeWasm() must be awaited first!");
627 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
628 return nativeResponseValue;
630 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
632 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
633 if(!isWasmInitialized) {
634 throw new Error("initializeWasm() must be awaited first!");
636 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
637 return nativeResponseValue;
639 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
641 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
642 if(!isWasmInitialized) {
643 throw new Error("initializeWasm() must be awaited first!");
645 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
646 return nativeResponseValue;
648 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
650 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
651 if(!isWasmInitialized) {
652 throw new Error("initializeWasm() must be awaited first!");
654 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
655 return nativeResponseValue;
657 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
659 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
660 if(!isWasmInitialized) {
661 throw new Error("initializeWasm() must be awaited first!");
663 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
664 return nativeResponseValue;
666 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
668 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
669 if(!isWasmInitialized) {
670 throw new Error("initializeWasm() must be awaited first!");
672 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
673 return nativeResponseValue;
675 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
677 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
678 if(!isWasmInitialized) {
679 throw new Error("initializeWasm() must be awaited first!");
681 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
682 return nativeResponseValue;
684 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
686 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
687 if(!isWasmInitialized) {
688 throw new Error("initializeWasm() must be awaited first!");
690 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
691 return nativeResponseValue;
693 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
695 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
696 if(!isWasmInitialized) {
697 throw new Error("initializeWasm() must be awaited first!");
699 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
700 return nativeResponseValue;
702 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
704 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
705 if(!isWasmInitialized) {
706 throw new Error("initializeWasm() must be awaited first!");
708 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
709 return nativeResponseValue;
711 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
713 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
714 if(!isWasmInitialized) {
715 throw new Error("initializeWasm() must be awaited first!");
717 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
718 return nativeResponseValue;
720 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
722 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
723 if(!isWasmInitialized) {
724 throw new Error("initializeWasm() must be awaited first!");
726 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
727 return nativeResponseValue;
730 export class LDKCOption_u32Z {
731 protected constructor() {}
734 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
735 if(!isWasmInitialized) {
736 throw new Error("initializeWasm() must be awaited first!");
738 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
739 return nativeResponseValue;
742 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
743 if(!isWasmInitialized) {
744 throw new Error("initializeWasm() must be awaited first!");
746 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
747 return nativeResponseValue;
749 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
751 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
752 if(!isWasmInitialized) {
753 throw new Error("initializeWasm() must be awaited first!");
755 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
756 return nativeResponseValue;
758 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
760 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
761 if(!isWasmInitialized) {
762 throw new Error("initializeWasm() must be awaited first!");
764 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
765 return nativeResponseValue;
767 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
769 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
770 if(!isWasmInitialized) {
771 throw new Error("initializeWasm() must be awaited first!");
773 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
774 return nativeResponseValue;
776 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
778 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
783 return nativeResponseValue;
785 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
787 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
788 if(!isWasmInitialized) {
789 throw new Error("initializeWasm() must be awaited first!");
791 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
792 return nativeResponseValue;
794 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
796 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
797 if(!isWasmInitialized) {
798 throw new Error("initializeWasm() must be awaited first!");
800 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
801 return nativeResponseValue;
803 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
805 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
806 if(!isWasmInitialized) {
807 throw new Error("initializeWasm() must be awaited first!");
809 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
810 return nativeResponseValue;
812 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
814 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
815 if(!isWasmInitialized) {
816 throw new Error("initializeWasm() must be awaited first!");
818 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
819 return nativeResponseValue;
821 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
823 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
824 if(!isWasmInitialized) {
825 throw new Error("initializeWasm() must be awaited first!");
827 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
828 return nativeResponseValue;
830 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
832 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
833 if(!isWasmInitialized) {
834 throw new Error("initializeWasm() must be awaited first!");
836 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
837 return nativeResponseValue;
839 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
841 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
842 if(!isWasmInitialized) {
843 throw new Error("initializeWasm() must be awaited first!");
845 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
846 return nativeResponseValue;
848 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
850 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
851 if(!isWasmInitialized) {
852 throw new Error("initializeWasm() must be awaited first!");
854 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
855 // debug statements here
857 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
859 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
860 if(!isWasmInitialized) {
861 throw new Error("initializeWasm() must be awaited first!");
863 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
864 return nativeResponseValue;
866 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
868 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
869 if(!isWasmInitialized) {
870 throw new Error("initializeWasm() must be awaited first!");
872 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
873 return nativeResponseValue;
875 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
877 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
878 if(!isWasmInitialized) {
879 throw new Error("initializeWasm() must be awaited first!");
881 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
882 return nativeResponseValue;
884 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
886 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
887 if(!isWasmInitialized) {
888 throw new Error("initializeWasm() must be awaited first!");
890 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
891 // debug statements here
893 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
895 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
896 if(!isWasmInitialized) {
897 throw new Error("initializeWasm() must be awaited first!");
899 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
900 return nativeResponseValue;
902 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
904 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
905 if(!isWasmInitialized) {
906 throw new Error("initializeWasm() must be awaited first!");
908 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
909 // debug statements here
911 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
913 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
914 if(!isWasmInitialized) {
915 throw new Error("initializeWasm() must be awaited first!");
917 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
918 return nativeResponseValue;
920 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
922 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
923 if(!isWasmInitialized) {
924 throw new Error("initializeWasm() must be awaited first!");
926 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
927 return nativeResponseValue;
929 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
931 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
932 if(!isWasmInitialized) {
933 throw new Error("initializeWasm() must be awaited first!");
935 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
936 return nativeResponseValue;
938 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
940 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
941 if(!isWasmInitialized) {
942 throw new Error("initializeWasm() must be awaited first!");
944 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
945 return nativeResponseValue;
947 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
949 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
950 if(!isWasmInitialized) {
951 throw new Error("initializeWasm() must be awaited first!");
953 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
954 return nativeResponseValue;
956 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
958 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
959 if(!isWasmInitialized) {
960 throw new Error("initializeWasm() must be awaited first!");
962 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
963 return nativeResponseValue;
965 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
967 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
968 if(!isWasmInitialized) {
969 throw new Error("initializeWasm() must be awaited first!");
971 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
972 return nativeResponseValue;
974 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
976 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
977 if(!isWasmInitialized) {
978 throw new Error("initializeWasm() must be awaited first!");
980 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
981 return nativeResponseValue;
983 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
985 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
986 if(!isWasmInitialized) {
987 throw new Error("initializeWasm() must be awaited first!");
989 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
990 return nativeResponseValue;
992 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
994 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
995 if(!isWasmInitialized) {
996 throw new Error("initializeWasm() must be awaited first!");
998 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
999 return nativeResponseValue;
1002 export class LDKCOption_u64Z {
1003 protected constructor() {}
1006 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1007 if(!isWasmInitialized) {
1008 throw new Error("initializeWasm() must be awaited first!");
1010 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1011 return nativeResponseValue;
1014 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1015 if(!isWasmInitialized) {
1016 throw new Error("initializeWasm() must be awaited first!");
1018 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1019 return nativeResponseValue;
1021 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1023 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
1024 if(!isWasmInitialized) {
1025 throw new Error("initializeWasm() must be awaited first!");
1027 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1028 return nativeResponseValue;
1030 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1032 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1033 if(!isWasmInitialized) {
1034 throw new Error("initializeWasm() must be awaited first!");
1036 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1037 return nativeResponseValue;
1039 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1041 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1042 if(!isWasmInitialized) {
1043 throw new Error("initializeWasm() must be awaited first!");
1045 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1046 return nativeResponseValue;
1048 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1050 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1051 if(!isWasmInitialized) {
1052 throw new Error("initializeWasm() must be awaited first!");
1054 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1055 return nativeResponseValue;
1057 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1059 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1060 if(!isWasmInitialized) {
1061 throw new Error("initializeWasm() must be awaited first!");
1063 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1064 return nativeResponseValue;
1066 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1068 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1069 if(!isWasmInitialized) {
1070 throw new Error("initializeWasm() must be awaited first!");
1072 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1073 return nativeResponseValue;
1075 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1077 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1078 if(!isWasmInitialized) {
1079 throw new Error("initializeWasm() must be awaited first!");
1081 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1082 return nativeResponseValue;
1084 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1086 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1087 if(!isWasmInitialized) {
1088 throw new Error("initializeWasm() must be awaited first!");
1090 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1091 return nativeResponseValue;
1093 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
1095 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
1096 if(!isWasmInitialized) {
1097 throw new Error("initializeWasm() must be awaited first!");
1099 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
1100 return nativeResponseValue;
1102 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
1104 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
1105 if(!isWasmInitialized) {
1106 throw new Error("initializeWasm() must be awaited first!");
1108 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
1109 return nativeResponseValue;
1111 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1113 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
1114 if(!isWasmInitialized) {
1115 throw new Error("initializeWasm() must be awaited first!");
1117 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
1118 return nativeResponseValue;
1120 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
1122 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
1123 if(!isWasmInitialized) {
1124 throw new Error("initializeWasm() must be awaited first!");
1126 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
1127 return nativeResponseValue;
1129 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
1131 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
1132 if(!isWasmInitialized) {
1133 throw new Error("initializeWasm() must be awaited first!");
1135 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
1136 // debug statements here
1138 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
1140 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
1141 if(!isWasmInitialized) {
1142 throw new Error("initializeWasm() must be awaited first!");
1144 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
1145 return nativeResponseValue;
1148 export class LDKMonitorEvent {
1149 protected constructor() {}
1152 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
1153 if(!isWasmInitialized) {
1154 throw new Error("initializeWasm() must be awaited first!");
1156 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
1157 return nativeResponseValue;
1160 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
1161 if(!isWasmInitialized) {
1162 throw new Error("initializeWasm() must be awaited first!");
1164 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
1165 return nativeResponseValue;
1168 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
1169 if(!isWasmInitialized) {
1170 throw new Error("initializeWasm() must be awaited first!");
1172 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
1173 return nativeResponseValue;
1176 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
1177 if(!isWasmInitialized) {
1178 throw new Error("initializeWasm() must be awaited first!");
1180 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
1181 return nativeResponseValue;
1184 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
1185 if(!isWasmInitialized) {
1186 throw new Error("initializeWasm() must be awaited first!");
1188 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
1189 return nativeResponseValue;
1192 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
1193 if(!isWasmInitialized) {
1194 throw new Error("initializeWasm() must be awaited first!");
1196 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
1197 return nativeResponseValue;
1200 export class LDKCOption_C2Tuple_usizeTransactionZZ {
1201 protected constructor() {}
1204 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
1205 if(!isWasmInitialized) {
1206 throw new Error("initializeWasm() must be awaited first!");
1208 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
1209 return nativeResponseValue;
1212 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
1213 if(!isWasmInitialized) {
1214 throw new Error("initializeWasm() must be awaited first!");
1216 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
1217 return nativeResponseValue;
1220 export class LDKClosureReason {
1221 protected constructor() {}
1224 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1225 if(!isWasmInitialized) {
1226 throw new Error("initializeWasm() must be awaited first!");
1228 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1229 return nativeResponseValue;
1232 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1237 return nativeResponseValue;
1240 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1241 if(!isWasmInitialized) {
1242 throw new Error("initializeWasm() must be awaited first!");
1244 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1245 return nativeResponseValue;
1248 export class LDKCOption_ClosureReasonZ {
1249 protected constructor() {}
1252 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1253 if(!isWasmInitialized) {
1254 throw new Error("initializeWasm() must be awaited first!");
1256 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1257 return nativeResponseValue;
1260 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1261 if(!isWasmInitialized) {
1262 throw new Error("initializeWasm() must be awaited first!");
1264 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1265 return nativeResponseValue;
1267 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1269 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1270 if(!isWasmInitialized) {
1271 throw new Error("initializeWasm() must be awaited first!");
1273 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1274 return nativeResponseValue;
1276 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1278 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1279 if(!isWasmInitialized) {
1280 throw new Error("initializeWasm() must be awaited first!");
1282 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1283 return nativeResponseValue;
1286 export class LDKNetworkUpdate {
1287 protected constructor() {}
1290 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1291 if(!isWasmInitialized) {
1292 throw new Error("initializeWasm() must be awaited first!");
1294 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1295 return nativeResponseValue;
1298 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1299 if(!isWasmInitialized) {
1300 throw new Error("initializeWasm() must be awaited first!");
1302 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1303 return nativeResponseValue;
1306 export function LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr: number): bigint {
1307 if(!isWasmInitialized) {
1308 throw new Error("initializeWasm() must be awaited first!");
1310 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_short_channel_id(ptr);
1311 return nativeResponseValue;
1314 export function LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr: number): boolean {
1315 if(!isWasmInitialized) {
1316 throw new Error("initializeWasm() must be awaited first!");
1318 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelClosed_get_is_permanent(ptr);
1319 return nativeResponseValue;
1322 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1323 if(!isWasmInitialized) {
1324 throw new Error("initializeWasm() must be awaited first!");
1326 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1327 return nativeResponseValue;
1330 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1331 if(!isWasmInitialized) {
1332 throw new Error("initializeWasm() must be awaited first!");
1334 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1335 return nativeResponseValue;
1338 export class LDKCOption_NetworkUpdateZ {
1339 protected constructor() {}
1342 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1343 if(!isWasmInitialized) {
1344 throw new Error("initializeWasm() must be awaited first!");
1346 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1347 return nativeResponseValue;
1350 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1351 if(!isWasmInitialized) {
1352 throw new Error("initializeWasm() must be awaited first!");
1354 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1355 return nativeResponseValue;
1358 export class LDKSpendableOutputDescriptor {
1359 protected constructor() {}
1362 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1363 if(!isWasmInitialized) {
1364 throw new Error("initializeWasm() must be awaited first!");
1366 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1367 return nativeResponseValue;
1370 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1371 if(!isWasmInitialized) {
1372 throw new Error("initializeWasm() must be awaited first!");
1374 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1375 return nativeResponseValue;
1378 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1379 if(!isWasmInitialized) {
1380 throw new Error("initializeWasm() must be awaited first!");
1382 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1383 return nativeResponseValue;
1386 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1387 if(!isWasmInitialized) {
1388 throw new Error("initializeWasm() must be awaited first!");
1390 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1391 return nativeResponseValue;
1394 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1395 if(!isWasmInitialized) {
1396 throw new Error("initializeWasm() must be awaited first!");
1398 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1399 return nativeResponseValue;
1402 export class LDKPaymentPurpose {
1403 protected constructor() {}
1406 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1407 if(!isWasmInitialized) {
1408 throw new Error("initializeWasm() must be awaited first!");
1410 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1411 return nativeResponseValue;
1414 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1415 if(!isWasmInitialized) {
1416 throw new Error("initializeWasm() must be awaited first!");
1418 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1419 return nativeResponseValue;
1422 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1423 if(!isWasmInitialized) {
1424 throw new Error("initializeWasm() must be awaited first!");
1426 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1427 return nativeResponseValue;
1430 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1431 if(!isWasmInitialized) {
1432 throw new Error("initializeWasm() must be awaited first!");
1434 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1435 return nativeResponseValue;
1438 export class LDKEvent {
1439 protected constructor() {}
1442 export function LDKEvent_ty_from_ptr(ptr: number): number {
1443 if(!isWasmInitialized) {
1444 throw new Error("initializeWasm() must be awaited first!");
1446 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1447 return nativeResponseValue;
1450 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1451 if(!isWasmInitialized) {
1452 throw new Error("initializeWasm() must be awaited first!");
1454 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1455 return nativeResponseValue;
1458 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1459 if(!isWasmInitialized) {
1460 throw new Error("initializeWasm() must be awaited first!");
1462 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1463 return nativeResponseValue;
1466 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1467 if(!isWasmInitialized) {
1468 throw new Error("initializeWasm() must be awaited first!");
1470 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1471 return nativeResponseValue;
1474 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1475 if(!isWasmInitialized) {
1476 throw new Error("initializeWasm() must be awaited first!");
1478 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1479 return nativeResponseValue;
1482 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1483 if(!isWasmInitialized) {
1484 throw new Error("initializeWasm() must be awaited first!");
1486 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1487 return nativeResponseValue;
1490 export function LDKEvent_PaymentReceived_get_amt(ptr: number): bigint {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amt(ptr);
1495 return nativeResponseValue;
1498 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1499 if(!isWasmInitialized) {
1500 throw new Error("initializeWasm() must be awaited first!");
1502 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1503 return nativeResponseValue;
1506 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1507 if(!isWasmInitialized) {
1508 throw new Error("initializeWasm() must be awaited first!");
1510 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1511 return nativeResponseValue;
1514 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1515 if(!isWasmInitialized) {
1516 throw new Error("initializeWasm() must be awaited first!");
1518 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1519 return nativeResponseValue;
1522 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1523 if(!isWasmInitialized) {
1524 throw new Error("initializeWasm() must be awaited first!");
1526 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1527 return nativeResponseValue;
1530 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1531 if(!isWasmInitialized) {
1532 throw new Error("initializeWasm() must be awaited first!");
1534 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1535 return nativeResponseValue;
1538 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1539 if(!isWasmInitialized) {
1540 throw new Error("initializeWasm() must be awaited first!");
1542 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1543 return nativeResponseValue;
1546 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1547 if(!isWasmInitialized) {
1548 throw new Error("initializeWasm() must be awaited first!");
1550 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1551 return nativeResponseValue;
1554 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1555 if(!isWasmInitialized) {
1556 throw new Error("initializeWasm() must be awaited first!");
1558 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1559 return nativeResponseValue;
1562 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1563 if(!isWasmInitialized) {
1564 throw new Error("initializeWasm() must be awaited first!");
1566 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1567 return nativeResponseValue;
1570 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1571 if(!isWasmInitialized) {
1572 throw new Error("initializeWasm() must be awaited first!");
1574 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1575 return nativeResponseValue;
1578 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1579 if(!isWasmInitialized) {
1580 throw new Error("initializeWasm() must be awaited first!");
1582 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1583 return nativeResponseValue;
1586 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1587 if(!isWasmInitialized) {
1588 throw new Error("initializeWasm() must be awaited first!");
1590 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1591 return nativeResponseValue;
1594 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1595 if(!isWasmInitialized) {
1596 throw new Error("initializeWasm() must be awaited first!");
1598 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1599 return nativeResponseValue;
1602 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1603 if(!isWasmInitialized) {
1604 throw new Error("initializeWasm() must be awaited first!");
1606 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1607 return nativeResponseValue;
1610 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1611 if(!isWasmInitialized) {
1612 throw new Error("initializeWasm() must be awaited first!");
1614 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1615 return nativeResponseValue;
1618 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1619 if(!isWasmInitialized) {
1620 throw new Error("initializeWasm() must be awaited first!");
1622 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1623 return nativeResponseValue;
1626 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1627 if(!isWasmInitialized) {
1628 throw new Error("initializeWasm() must be awaited first!");
1630 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1631 return nativeResponseValue;
1634 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1635 if(!isWasmInitialized) {
1636 throw new Error("initializeWasm() must be awaited first!");
1638 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1639 return nativeResponseValue;
1642 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1643 if(!isWasmInitialized) {
1644 throw new Error("initializeWasm() must be awaited first!");
1646 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1647 return nativeResponseValue;
1650 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1651 if(!isWasmInitialized) {
1652 throw new Error("initializeWasm() must be awaited first!");
1654 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1655 return nativeResponseValue;
1658 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1659 if(!isWasmInitialized) {
1660 throw new Error("initializeWasm() must be awaited first!");
1662 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1663 return nativeResponseValue;
1666 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1667 if(!isWasmInitialized) {
1668 throw new Error("initializeWasm() must be awaited first!");
1670 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1671 return nativeResponseValue;
1674 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1675 if(!isWasmInitialized) {
1676 throw new Error("initializeWasm() must be awaited first!");
1678 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1679 return nativeResponseValue;
1682 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1683 if(!isWasmInitialized) {
1684 throw new Error("initializeWasm() must be awaited first!");
1686 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1687 return nativeResponseValue;
1690 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1691 if(!isWasmInitialized) {
1692 throw new Error("initializeWasm() must be awaited first!");
1694 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1695 return nativeResponseValue;
1698 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1699 if(!isWasmInitialized) {
1700 throw new Error("initializeWasm() must be awaited first!");
1702 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1703 return nativeResponseValue;
1706 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1707 if(!isWasmInitialized) {
1708 throw new Error("initializeWasm() must be awaited first!");
1710 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1711 return nativeResponseValue;
1714 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1715 if(!isWasmInitialized) {
1716 throw new Error("initializeWasm() must be awaited first!");
1718 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1719 return nativeResponseValue;
1722 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1723 if(!isWasmInitialized) {
1724 throw new Error("initializeWasm() must be awaited first!");
1726 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1727 return nativeResponseValue;
1730 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1731 if(!isWasmInitialized) {
1732 throw new Error("initializeWasm() must be awaited first!");
1734 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1735 return nativeResponseValue;
1738 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1739 if(!isWasmInitialized) {
1740 throw new Error("initializeWasm() must be awaited first!");
1742 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1743 return nativeResponseValue;
1746 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1747 if(!isWasmInitialized) {
1748 throw new Error("initializeWasm() must be awaited first!");
1750 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1751 return nativeResponseValue;
1754 export class LDKCOption_EventZ {
1755 protected constructor() {}
1758 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1759 if(!isWasmInitialized) {
1760 throw new Error("initializeWasm() must be awaited first!");
1762 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1763 return nativeResponseValue;
1766 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1767 if(!isWasmInitialized) {
1768 throw new Error("initializeWasm() must be awaited first!");
1770 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1771 return nativeResponseValue;
1773 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1775 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1776 if(!isWasmInitialized) {
1777 throw new Error("initializeWasm() must be awaited first!");
1779 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1780 return nativeResponseValue;
1782 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1784 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1785 if(!isWasmInitialized) {
1786 throw new Error("initializeWasm() must be awaited first!");
1788 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1789 return nativeResponseValue;
1792 export class LDKErrorAction {
1793 protected constructor() {}
1796 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1797 if(!isWasmInitialized) {
1798 throw new Error("initializeWasm() must be awaited first!");
1800 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1801 return nativeResponseValue;
1804 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1805 if(!isWasmInitialized) {
1806 throw new Error("initializeWasm() must be awaited first!");
1808 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1809 return nativeResponseValue;
1812 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1813 if(!isWasmInitialized) {
1814 throw new Error("initializeWasm() must be awaited first!");
1816 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1817 return nativeResponseValue;
1820 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1821 if(!isWasmInitialized) {
1822 throw new Error("initializeWasm() must be awaited first!");
1824 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1825 return nativeResponseValue;
1828 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1829 if(!isWasmInitialized) {
1830 throw new Error("initializeWasm() must be awaited first!");
1832 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
1833 return nativeResponseValue;
1836 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
1837 if(!isWasmInitialized) {
1838 throw new Error("initializeWasm() must be awaited first!");
1840 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
1841 return nativeResponseValue;
1844 export class LDKMessageSendEvent {
1845 protected constructor() {}
1848 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
1849 if(!isWasmInitialized) {
1850 throw new Error("initializeWasm() must be awaited first!");
1852 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
1853 return nativeResponseValue;
1856 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
1857 if(!isWasmInitialized) {
1858 throw new Error("initializeWasm() must be awaited first!");
1860 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
1861 return nativeResponseValue;
1864 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
1865 if(!isWasmInitialized) {
1866 throw new Error("initializeWasm() must be awaited first!");
1868 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
1869 return nativeResponseValue;
1872 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
1873 if(!isWasmInitialized) {
1874 throw new Error("initializeWasm() must be awaited first!");
1876 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
1877 return nativeResponseValue;
1880 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
1881 if(!isWasmInitialized) {
1882 throw new Error("initializeWasm() must be awaited first!");
1884 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
1885 return nativeResponseValue;
1888 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
1889 if(!isWasmInitialized) {
1890 throw new Error("initializeWasm() must be awaited first!");
1892 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
1893 return nativeResponseValue;
1896 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
1897 if(!isWasmInitialized) {
1898 throw new Error("initializeWasm() must be awaited first!");
1900 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
1901 return nativeResponseValue;
1904 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
1905 if(!isWasmInitialized) {
1906 throw new Error("initializeWasm() must be awaited first!");
1908 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
1909 return nativeResponseValue;
1912 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
1913 if(!isWasmInitialized) {
1914 throw new Error("initializeWasm() must be awaited first!");
1916 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
1917 return nativeResponseValue;
1920 export function LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr: number): number {
1921 if(!isWasmInitialized) {
1922 throw new Error("initializeWasm() must be awaited first!");
1924 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_node_id(ptr);
1925 return nativeResponseValue;
1928 export function LDKMessageSendEvent_SendFundingLocked_get_msg(ptr: number): number {
1929 if(!isWasmInitialized) {
1930 throw new Error("initializeWasm() must be awaited first!");
1932 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingLocked_get_msg(ptr);
1933 return nativeResponseValue;
1936 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
1937 if(!isWasmInitialized) {
1938 throw new Error("initializeWasm() must be awaited first!");
1940 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
1941 return nativeResponseValue;
1944 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
1945 if(!isWasmInitialized) {
1946 throw new Error("initializeWasm() must be awaited first!");
1948 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
1949 return nativeResponseValue;
1952 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
1953 if(!isWasmInitialized) {
1954 throw new Error("initializeWasm() must be awaited first!");
1956 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
1957 return nativeResponseValue;
1960 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
1961 if(!isWasmInitialized) {
1962 throw new Error("initializeWasm() must be awaited first!");
1964 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
1965 return nativeResponseValue;
1968 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
1973 return nativeResponseValue;
1976 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
1977 if(!isWasmInitialized) {
1978 throw new Error("initializeWasm() must be awaited first!");
1980 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
1981 return nativeResponseValue;
1984 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
1985 if(!isWasmInitialized) {
1986 throw new Error("initializeWasm() must be awaited first!");
1988 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
1989 return nativeResponseValue;
1992 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
1993 if(!isWasmInitialized) {
1994 throw new Error("initializeWasm() must be awaited first!");
1996 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
1997 return nativeResponseValue;
2000 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
2001 if(!isWasmInitialized) {
2002 throw new Error("initializeWasm() must be awaited first!");
2004 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2005 return nativeResponseValue;
2008 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
2009 if(!isWasmInitialized) {
2010 throw new Error("initializeWasm() must be awaited first!");
2012 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2013 return nativeResponseValue;
2016 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2017 if(!isWasmInitialized) {
2018 throw new Error("initializeWasm() must be awaited first!");
2020 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2021 return nativeResponseValue;
2024 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2025 if(!isWasmInitialized) {
2026 throw new Error("initializeWasm() must be awaited first!");
2028 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2029 return nativeResponseValue;
2032 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2033 if(!isWasmInitialized) {
2034 throw new Error("initializeWasm() must be awaited first!");
2036 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2037 return nativeResponseValue;
2040 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2041 if(!isWasmInitialized) {
2042 throw new Error("initializeWasm() must be awaited first!");
2044 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2045 return nativeResponseValue;
2048 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2049 if(!isWasmInitialized) {
2050 throw new Error("initializeWasm() must be awaited first!");
2052 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2053 return nativeResponseValue;
2056 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2057 if(!isWasmInitialized) {
2058 throw new Error("initializeWasm() must be awaited first!");
2060 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2061 return nativeResponseValue;
2064 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2065 if(!isWasmInitialized) {
2066 throw new Error("initializeWasm() must be awaited first!");
2068 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2069 return nativeResponseValue;
2072 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2073 if(!isWasmInitialized) {
2074 throw new Error("initializeWasm() must be awaited first!");
2076 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2077 return nativeResponseValue;
2080 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2081 if(!isWasmInitialized) {
2082 throw new Error("initializeWasm() must be awaited first!");
2084 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2085 return nativeResponseValue;
2088 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2089 if(!isWasmInitialized) {
2090 throw new Error("initializeWasm() must be awaited first!");
2092 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2093 return nativeResponseValue;
2096 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2097 if(!isWasmInitialized) {
2098 throw new Error("initializeWasm() must be awaited first!");
2100 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2101 return nativeResponseValue;
2104 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2105 if(!isWasmInitialized) {
2106 throw new Error("initializeWasm() must be awaited first!");
2108 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2109 return nativeResponseValue;
2112 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2113 if(!isWasmInitialized) {
2114 throw new Error("initializeWasm() must be awaited first!");
2116 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2117 return nativeResponseValue;
2120 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2121 if(!isWasmInitialized) {
2122 throw new Error("initializeWasm() must be awaited first!");
2124 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2125 return nativeResponseValue;
2128 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2129 if(!isWasmInitialized) {
2130 throw new Error("initializeWasm() must be awaited first!");
2132 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2133 return nativeResponseValue;
2136 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2137 if(!isWasmInitialized) {
2138 throw new Error("initializeWasm() must be awaited first!");
2140 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2141 return nativeResponseValue;
2144 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2145 if(!isWasmInitialized) {
2146 throw new Error("initializeWasm() must be awaited first!");
2148 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2149 return nativeResponseValue;
2152 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2153 if(!isWasmInitialized) {
2154 throw new Error("initializeWasm() must be awaited first!");
2156 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2157 return nativeResponseValue;
2159 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2161 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2162 if(!isWasmInitialized) {
2163 throw new Error("initializeWasm() must be awaited first!");
2165 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2166 return nativeResponseValue;
2168 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2170 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2171 if(!isWasmInitialized) {
2172 throw new Error("initializeWasm() must be awaited first!");
2174 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2175 return nativeResponseValue;
2177 // struct LDKScoringParameters CResult_ScoringParametersDecodeErrorZ_get_ok(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2179 export function CResult_ScoringParametersDecodeErrorZ_get_ok(owner: number): number {
2180 if(!isWasmInitialized) {
2181 throw new Error("initializeWasm() must be awaited first!");
2183 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_ok(owner);
2184 return nativeResponseValue;
2186 // struct LDKDecodeError CResult_ScoringParametersDecodeErrorZ_get_err(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR owner);
2188 export function CResult_ScoringParametersDecodeErrorZ_get_err(owner: number): number {
2189 if(!isWasmInitialized) {
2190 throw new Error("initializeWasm() must be awaited first!");
2192 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_get_err(owner);
2193 return nativeResponseValue;
2195 // struct LDKScorer *CResult_ScorerDecodeErrorZ_get_ok(LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR owner);
2197 export function CResult_ScorerDecodeErrorZ_get_ok(owner: number): number {
2198 if(!isWasmInitialized) {
2199 throw new Error("initializeWasm() must be awaited first!");
2201 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_get_ok(owner);
2202 return nativeResponseValue;
2204 // struct LDKDecodeError CResult_ScorerDecodeErrorZ_get_err(LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR owner);
2206 export function CResult_ScorerDecodeErrorZ_get_err(owner: number): number {
2207 if(!isWasmInitialized) {
2208 throw new Error("initializeWasm() must be awaited first!");
2210 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_get_err(owner);
2211 return nativeResponseValue;
2213 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2215 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2216 if(!isWasmInitialized) {
2217 throw new Error("initializeWasm() must be awaited first!");
2219 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2220 return nativeResponseValue;
2222 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2224 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2225 if(!isWasmInitialized) {
2226 throw new Error("initializeWasm() must be awaited first!");
2228 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2229 return nativeResponseValue;
2231 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2233 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2234 if(!isWasmInitialized) {
2235 throw new Error("initializeWasm() must be awaited first!");
2237 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2238 return nativeResponseValue;
2240 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2242 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2243 if(!isWasmInitialized) {
2244 throw new Error("initializeWasm() must be awaited first!");
2246 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2247 return nativeResponseValue;
2249 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2251 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2252 if(!isWasmInitialized) {
2253 throw new Error("initializeWasm() must be awaited first!");
2255 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2256 return nativeResponseValue;
2258 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2260 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2261 if(!isWasmInitialized) {
2262 throw new Error("initializeWasm() must be awaited first!");
2264 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2265 return nativeResponseValue;
2267 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2269 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2270 if(!isWasmInitialized) {
2271 throw new Error("initializeWasm() must be awaited first!");
2273 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2274 return nativeResponseValue;
2276 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2278 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2279 if(!isWasmInitialized) {
2280 throw new Error("initializeWasm() must be awaited first!");
2282 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2283 return nativeResponseValue;
2285 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2287 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2288 if(!isWasmInitialized) {
2289 throw new Error("initializeWasm() must be awaited first!");
2291 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2292 return nativeResponseValue;
2294 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2296 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2297 if(!isWasmInitialized) {
2298 throw new Error("initializeWasm() must be awaited first!");
2300 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2301 return nativeResponseValue;
2303 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2305 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2306 if(!isWasmInitialized) {
2307 throw new Error("initializeWasm() must be awaited first!");
2309 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2310 return nativeResponseValue;
2312 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2314 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2315 if(!isWasmInitialized) {
2316 throw new Error("initializeWasm() must be awaited first!");
2318 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2319 return nativeResponseValue;
2321 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2323 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2324 if(!isWasmInitialized) {
2325 throw new Error("initializeWasm() must be awaited first!");
2327 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2328 return nativeResponseValue;
2330 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2332 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2333 if(!isWasmInitialized) {
2334 throw new Error("initializeWasm() must be awaited first!");
2336 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2337 return nativeResponseValue;
2339 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2341 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2342 if(!isWasmInitialized) {
2343 throw new Error("initializeWasm() must be awaited first!");
2345 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2346 return nativeResponseValue;
2348 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2350 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2351 if(!isWasmInitialized) {
2352 throw new Error("initializeWasm() must be awaited first!");
2354 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2355 return nativeResponseValue;
2357 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2359 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2360 if(!isWasmInitialized) {
2361 throw new Error("initializeWasm() must be awaited first!");
2363 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2364 return nativeResponseValue;
2366 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2368 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2369 if(!isWasmInitialized) {
2370 throw new Error("initializeWasm() must be awaited first!");
2372 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2373 return nativeResponseValue;
2375 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2377 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2378 if(!isWasmInitialized) {
2379 throw new Error("initializeWasm() must be awaited first!");
2381 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2382 return nativeResponseValue;
2384 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2386 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2387 if(!isWasmInitialized) {
2388 throw new Error("initializeWasm() must be awaited first!");
2390 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2391 return nativeResponseValue;
2393 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2395 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2396 if(!isWasmInitialized) {
2397 throw new Error("initializeWasm() must be awaited first!");
2399 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2400 return nativeResponseValue;
2402 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2404 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2405 if(!isWasmInitialized) {
2406 throw new Error("initializeWasm() must be awaited first!");
2408 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2409 // debug statements here
2411 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2413 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2414 if(!isWasmInitialized) {
2415 throw new Error("initializeWasm() must be awaited first!");
2417 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2418 return nativeResponseValue;
2420 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2422 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2423 if(!isWasmInitialized) {
2424 throw new Error("initializeWasm() must be awaited first!");
2426 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2427 // debug statements here
2429 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2431 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2432 if(!isWasmInitialized) {
2433 throw new Error("initializeWasm() must be awaited first!");
2435 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2436 return nativeResponseValue;
2438 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2440 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2441 if(!isWasmInitialized) {
2442 throw new Error("initializeWasm() must be awaited first!");
2444 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2445 return nativeResponseValue;
2447 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2449 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
2450 if(!isWasmInitialized) {
2451 throw new Error("initializeWasm() must be awaited first!");
2453 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
2454 return nativeResponseValue;
2456 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2458 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
2459 if(!isWasmInitialized) {
2460 throw new Error("initializeWasm() must be awaited first!");
2462 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
2463 // debug statements here
2465 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2467 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
2468 if(!isWasmInitialized) {
2469 throw new Error("initializeWasm() must be awaited first!");
2471 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
2472 return nativeResponseValue;
2474 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2476 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
2477 if(!isWasmInitialized) {
2478 throw new Error("initializeWasm() must be awaited first!");
2480 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
2481 // debug statements here
2484 export interface LDKBaseSign {
2485 get_per_commitment_point (idx: bigint): number;
2486 release_commitment_secret (idx: bigint): number;
2487 validate_holder_commitment (holder_tx: number, preimages: number): number;
2488 channel_keys_id (): number;
2489 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
2490 validate_counterparty_revocation (idx: bigint, secret: number): number;
2491 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
2492 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
2493 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
2494 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
2495 sign_closing_transaction (closing_tx: number): number;
2496 sign_channel_announcement (msg: number): number;
2497 ready_channel (channel_parameters: number): void;
2501 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
2502 if(!isWasmInitialized) {
2503 throw new Error("initializeWasm() must be awaited first!");
2505 var new_obj_idx = js_objs.length;
2506 for (var i = 0; i < js_objs.length; i++) {
2507 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2509 js_objs[i] = new WeakRef(impl);
2510 return wasm.TS_LDKBaseSign_new(i);
2512 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2514 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
2515 if(!isWasmInitialized) {
2516 throw new Error("initializeWasm() must be awaited first!");
2518 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
2519 return nativeResponseValue;
2521 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2523 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
2524 if(!isWasmInitialized) {
2525 throw new Error("initializeWasm() must be awaited first!");
2527 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
2528 return nativeResponseValue;
2530 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
2532 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
2533 if(!isWasmInitialized) {
2534 throw new Error("initializeWasm() must be awaited first!");
2536 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
2537 return nativeResponseValue;
2539 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
2541 export function BaseSign_channel_keys_id(this_arg: number): number {
2542 if(!isWasmInitialized) {
2543 throw new Error("initializeWasm() must be awaited first!");
2545 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
2546 return nativeResponseValue;
2548 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
2550 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
2551 if(!isWasmInitialized) {
2552 throw new Error("initializeWasm() must be awaited first!");
2554 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
2555 return nativeResponseValue;
2557 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
2559 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
2560 if(!isWasmInitialized) {
2561 throw new Error("initializeWasm() must be awaited first!");
2563 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
2564 return nativeResponseValue;
2566 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
2568 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
2569 if(!isWasmInitialized) {
2570 throw new Error("initializeWasm() must be awaited first!");
2572 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
2573 return nativeResponseValue;
2575 // 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]
2577 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
2578 if(!isWasmInitialized) {
2579 throw new Error("initializeWasm() must be awaited first!");
2581 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
2582 return nativeResponseValue;
2584 // 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
2586 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
2587 if(!isWasmInitialized) {
2588 throw new Error("initializeWasm() must be awaited first!");
2590 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
2591 return nativeResponseValue;
2593 // 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
2595 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
2596 if(!isWasmInitialized) {
2597 throw new Error("initializeWasm() must be awaited first!");
2599 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
2600 return nativeResponseValue;
2602 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
2604 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
2605 if(!isWasmInitialized) {
2606 throw new Error("initializeWasm() must be awaited first!");
2608 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
2609 return nativeResponseValue;
2611 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
2613 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
2614 if(!isWasmInitialized) {
2615 throw new Error("initializeWasm() must be awaited first!");
2617 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
2618 return nativeResponseValue;
2620 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
2622 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
2623 if(!isWasmInitialized) {
2624 throw new Error("initializeWasm() must be awaited first!");
2626 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
2627 // debug statements here
2629 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
2631 export function BaseSign_get_pubkeys(this_arg: number): number {
2632 if(!isWasmInitialized) {
2633 throw new Error("initializeWasm() must be awaited first!");
2635 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
2636 return nativeResponseValue;
2639 export interface LDKSign {
2644 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
2645 if(!isWasmInitialized) {
2646 throw new Error("initializeWasm() must be awaited first!");
2648 var new_obj_idx = js_objs.length;
2649 for (var i = 0; i < js_objs.length; i++) {
2650 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2652 js_objs[i] = new WeakRef(impl);
2653 return wasm.TS_LDKSign_new(i);
2655 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
2657 export function Sign_write(this_arg: number): number {
2658 if(!isWasmInitialized) {
2659 throw new Error("initializeWasm() must be awaited first!");
2661 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
2662 return nativeResponseValue;
2664 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
2666 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
2667 if(!isWasmInitialized) {
2668 throw new Error("initializeWasm() must be awaited first!");
2670 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
2671 return nativeResponseValue;
2673 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
2675 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
2676 if(!isWasmInitialized) {
2677 throw new Error("initializeWasm() must be awaited first!");
2679 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
2680 return nativeResponseValue;
2682 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2684 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
2685 if(!isWasmInitialized) {
2686 throw new Error("initializeWasm() must be awaited first!");
2688 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
2689 return nativeResponseValue;
2691 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
2693 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
2694 if(!isWasmInitialized) {
2695 throw new Error("initializeWasm() must be awaited first!");
2697 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
2698 // debug statements here
2700 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2702 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
2703 if(!isWasmInitialized) {
2704 throw new Error("initializeWasm() must be awaited first!");
2706 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
2707 return nativeResponseValue;
2709 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
2711 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
2712 if(!isWasmInitialized) {
2713 throw new Error("initializeWasm() must be awaited first!");
2715 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
2716 // debug statements here
2718 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2720 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
2721 if(!isWasmInitialized) {
2722 throw new Error("initializeWasm() must be awaited first!");
2724 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
2725 return nativeResponseValue;
2727 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
2729 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
2730 if(!isWasmInitialized) {
2731 throw new Error("initializeWasm() must be awaited first!");
2733 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
2734 return nativeResponseValue;
2736 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2738 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
2739 if(!isWasmInitialized) {
2740 throw new Error("initializeWasm() must be awaited first!");
2742 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
2743 return nativeResponseValue;
2745 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
2747 export function CResult_TransactionNoneZ_get_err(owner: number): void {
2748 if(!isWasmInitialized) {
2749 throw new Error("initializeWasm() must be awaited first!");
2751 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
2752 // debug statements here
2755 export class LDKCOption_u16Z {
2756 protected constructor() {}
2759 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
2760 if(!isWasmInitialized) {
2761 throw new Error("initializeWasm() must be awaited first!");
2763 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
2764 return nativeResponseValue;
2767 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
2768 if(!isWasmInitialized) {
2769 throw new Error("initializeWasm() must be awaited first!");
2771 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
2772 return nativeResponseValue;
2775 export class LDKAPIError {
2776 protected constructor() {}
2779 export function LDKAPIError_ty_from_ptr(ptr: number): number {
2780 if(!isWasmInitialized) {
2781 throw new Error("initializeWasm() must be awaited first!");
2783 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
2784 return nativeResponseValue;
2787 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
2788 if(!isWasmInitialized) {
2789 throw new Error("initializeWasm() must be awaited first!");
2791 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
2792 return nativeResponseValue;
2795 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
2796 if(!isWasmInitialized) {
2797 throw new Error("initializeWasm() must be awaited first!");
2799 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
2800 return nativeResponseValue;
2803 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
2804 if(!isWasmInitialized) {
2805 throw new Error("initializeWasm() must be awaited first!");
2807 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
2808 return nativeResponseValue;
2811 export function LDKAPIError_RouteError_get_err(ptr: number): number {
2812 if(!isWasmInitialized) {
2813 throw new Error("initializeWasm() must be awaited first!");
2815 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
2816 return nativeResponseValue;
2819 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
2820 if(!isWasmInitialized) {
2821 throw new Error("initializeWasm() must be awaited first!");
2823 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
2824 return nativeResponseValue;
2827 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
2828 if(!isWasmInitialized) {
2829 throw new Error("initializeWasm() must be awaited first!");
2831 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
2832 return nativeResponseValue;
2834 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
2836 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
2837 if(!isWasmInitialized) {
2838 throw new Error("initializeWasm() must be awaited first!");
2840 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
2841 // debug statements here
2843 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
2845 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
2846 if(!isWasmInitialized) {
2847 throw new Error("initializeWasm() must be awaited first!");
2849 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
2850 return nativeResponseValue;
2852 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
2854 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
2855 if(!isWasmInitialized) {
2856 throw new Error("initializeWasm() must be awaited first!");
2858 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
2859 return nativeResponseValue;
2861 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
2863 export function CResult__u832APIErrorZ_get_err(owner: number): number {
2864 if(!isWasmInitialized) {
2865 throw new Error("initializeWasm() must be awaited first!");
2867 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
2868 return nativeResponseValue;
2871 export class LDKPaymentSendFailure {
2872 protected constructor() {}
2875 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
2876 if(!isWasmInitialized) {
2877 throw new Error("initializeWasm() must be awaited first!");
2879 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
2880 return nativeResponseValue;
2883 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
2884 if(!isWasmInitialized) {
2885 throw new Error("initializeWasm() must be awaited first!");
2887 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
2888 return nativeResponseValue;
2891 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
2892 if(!isWasmInitialized) {
2893 throw new Error("initializeWasm() must be awaited first!");
2895 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
2896 return nativeResponseValue;
2899 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
2900 if(!isWasmInitialized) {
2901 throw new Error("initializeWasm() must be awaited first!");
2903 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
2904 return nativeResponseValue;
2907 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
2908 if(!isWasmInitialized) {
2909 throw new Error("initializeWasm() must be awaited first!");
2911 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
2912 return nativeResponseValue;
2915 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
2916 if(!isWasmInitialized) {
2917 throw new Error("initializeWasm() must be awaited first!");
2919 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
2920 return nativeResponseValue;
2923 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
2924 if(!isWasmInitialized) {
2925 throw new Error("initializeWasm() must be awaited first!");
2927 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
2928 return nativeResponseValue;
2930 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
2932 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
2933 if(!isWasmInitialized) {
2934 throw new Error("initializeWasm() must be awaited first!");
2936 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
2937 return nativeResponseValue;
2939 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
2941 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
2942 if(!isWasmInitialized) {
2943 throw new Error("initializeWasm() must be awaited first!");
2945 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
2946 return nativeResponseValue;
2948 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
2950 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
2951 if(!isWasmInitialized) {
2952 throw new Error("initializeWasm() must be awaited first!");
2954 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
2955 // debug statements here
2957 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
2959 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
2960 if(!isWasmInitialized) {
2961 throw new Error("initializeWasm() must be awaited first!");
2963 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
2964 return nativeResponseValue;
2966 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
2968 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
2969 if(!isWasmInitialized) {
2970 throw new Error("initializeWasm() must be awaited first!");
2972 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
2973 return nativeResponseValue;
2975 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
2977 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
2978 if(!isWasmInitialized) {
2979 throw new Error("initializeWasm() must be awaited first!");
2981 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
2982 return nativeResponseValue;
2984 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
2986 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
2987 if(!isWasmInitialized) {
2988 throw new Error("initializeWasm() must be awaited first!");
2990 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
2991 return nativeResponseValue;
2993 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
2995 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
2996 if(!isWasmInitialized) {
2997 throw new Error("initializeWasm() must be awaited first!");
2999 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3000 return nativeResponseValue;
3003 export class LDKNetAddress {
3004 protected constructor() {}
3007 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
3008 if(!isWasmInitialized) {
3009 throw new Error("initializeWasm() must be awaited first!");
3011 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
3012 return nativeResponseValue;
3015 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
3016 if(!isWasmInitialized) {
3017 throw new Error("initializeWasm() must be awaited first!");
3019 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
3020 return nativeResponseValue;
3023 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
3024 if(!isWasmInitialized) {
3025 throw new Error("initializeWasm() must be awaited first!");
3027 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
3028 return nativeResponseValue;
3031 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
3032 if(!isWasmInitialized) {
3033 throw new Error("initializeWasm() must be awaited first!");
3035 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
3036 return nativeResponseValue;
3039 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
3040 if(!isWasmInitialized) {
3041 throw new Error("initializeWasm() must be awaited first!");
3043 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
3044 return nativeResponseValue;
3047 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
3048 if(!isWasmInitialized) {
3049 throw new Error("initializeWasm() must be awaited first!");
3051 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
3052 return nativeResponseValue;
3055 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
3056 if(!isWasmInitialized) {
3057 throw new Error("initializeWasm() must be awaited first!");
3059 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
3060 return nativeResponseValue;
3063 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
3068 return nativeResponseValue;
3071 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
3072 if(!isWasmInitialized) {
3073 throw new Error("initializeWasm() must be awaited first!");
3075 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
3076 return nativeResponseValue;
3079 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
3080 if(!isWasmInitialized) {
3081 throw new Error("initializeWasm() must be awaited first!");
3083 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
3084 return nativeResponseValue;
3086 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3088 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3089 if(!isWasmInitialized) {
3090 throw new Error("initializeWasm() must be awaited first!");
3092 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3093 return nativeResponseValue;
3095 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3097 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3098 if(!isWasmInitialized) {
3099 throw new Error("initializeWasm() must be awaited first!");
3101 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3102 return nativeResponseValue;
3104 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3106 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3107 if(!isWasmInitialized) {
3108 throw new Error("initializeWasm() must be awaited first!");
3110 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3111 return nativeResponseValue;
3113 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3115 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3116 if(!isWasmInitialized) {
3117 throw new Error("initializeWasm() must be awaited first!");
3119 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3120 // debug statements here
3122 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3124 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3125 if(!isWasmInitialized) {
3126 throw new Error("initializeWasm() must be awaited first!");
3128 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3129 return nativeResponseValue;
3131 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3133 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3134 if(!isWasmInitialized) {
3135 throw new Error("initializeWasm() must be awaited first!");
3137 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3138 return nativeResponseValue;
3140 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3142 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3143 if(!isWasmInitialized) {
3144 throw new Error("initializeWasm() must be awaited first!");
3146 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3147 return nativeResponseValue;
3149 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3151 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3152 if(!isWasmInitialized) {
3153 throw new Error("initializeWasm() must be awaited first!");
3155 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3156 // debug statements here
3158 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3160 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3161 if(!isWasmInitialized) {
3162 throw new Error("initializeWasm() must be awaited first!");
3164 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3165 return nativeResponseValue;
3167 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3169 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3170 if(!isWasmInitialized) {
3171 throw new Error("initializeWasm() must be awaited first!");
3173 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3174 return nativeResponseValue;
3176 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3178 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3179 if(!isWasmInitialized) {
3180 throw new Error("initializeWasm() must be awaited first!");
3182 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3183 return nativeResponseValue;
3185 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3187 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3188 if(!isWasmInitialized) {
3189 throw new Error("initializeWasm() must be awaited first!");
3191 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3192 return nativeResponseValue;
3194 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3196 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3197 if(!isWasmInitialized) {
3198 throw new Error("initializeWasm() must be awaited first!");
3200 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3201 return nativeResponseValue;
3203 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3205 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3206 if(!isWasmInitialized) {
3207 throw new Error("initializeWasm() must be awaited first!");
3209 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3210 return nativeResponseValue;
3212 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3214 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3215 if(!isWasmInitialized) {
3216 throw new Error("initializeWasm() must be awaited first!");
3218 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3219 return nativeResponseValue;
3221 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3223 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3224 if(!isWasmInitialized) {
3225 throw new Error("initializeWasm() must be awaited first!");
3227 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3228 return nativeResponseValue;
3230 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3232 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3233 if(!isWasmInitialized) {
3234 throw new Error("initializeWasm() must be awaited first!");
3236 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3237 return nativeResponseValue;
3239 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3241 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3242 if(!isWasmInitialized) {
3243 throw new Error("initializeWasm() must be awaited first!");
3245 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3246 return nativeResponseValue;
3248 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3250 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3251 if(!isWasmInitialized) {
3252 throw new Error("initializeWasm() must be awaited first!");
3254 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3255 return nativeResponseValue;
3257 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3259 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3260 if(!isWasmInitialized) {
3261 throw new Error("initializeWasm() must be awaited first!");
3263 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3264 return nativeResponseValue;
3267 export interface LDKWatch {
3268 watch_channel (funding_txo: number, monitor: number): number;
3269 update_channel (funding_txo: number, update: number): number;
3270 release_pending_monitor_events (): number;
3274 export function LDKWatch_new(impl: LDKWatch): number {
3275 if(!isWasmInitialized) {
3276 throw new Error("initializeWasm() must be awaited first!");
3278 var new_obj_idx = js_objs.length;
3279 for (var i = 0; i < js_objs.length; i++) {
3280 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3282 js_objs[i] = new WeakRef(impl);
3283 return wasm.TS_LDKWatch_new(i);
3285 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3287 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3288 if(!isWasmInitialized) {
3289 throw new Error("initializeWasm() must be awaited first!");
3291 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3292 return nativeResponseValue;
3294 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3296 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3297 if(!isWasmInitialized) {
3298 throw new Error("initializeWasm() must be awaited first!");
3300 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3301 return nativeResponseValue;
3303 // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3305 export function Watch_release_pending_monitor_events(this_arg: number): number {
3306 if(!isWasmInitialized) {
3307 throw new Error("initializeWasm() must be awaited first!");
3309 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3310 return nativeResponseValue;
3313 export interface LDKBroadcasterInterface {
3314 broadcast_transaction (tx: number): void;
3318 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3319 if(!isWasmInitialized) {
3320 throw new Error("initializeWasm() must be awaited first!");
3322 var new_obj_idx = js_objs.length;
3323 for (var i = 0; i < js_objs.length; i++) {
3324 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3326 js_objs[i] = new WeakRef(impl);
3327 return wasm.TS_LDKBroadcasterInterface_new(i);
3329 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3331 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3332 if(!isWasmInitialized) {
3333 throw new Error("initializeWasm() must be awaited first!");
3335 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3336 // debug statements here
3339 export interface LDKKeysInterface {
3340 get_node_secret (recipient: Recipient): number;
3341 get_destination_script (): number;
3342 get_shutdown_scriptpubkey (): number;
3343 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3344 get_secure_random_bytes (): number;
3345 read_chan_signer (reader: number): number;
3346 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3347 get_inbound_payment_key_material (): number;
3351 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3352 if(!isWasmInitialized) {
3353 throw new Error("initializeWasm() must be awaited first!");
3355 var new_obj_idx = js_objs.length;
3356 for (var i = 0; i < js_objs.length; i++) {
3357 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3359 js_objs[i] = new WeakRef(impl);
3360 return wasm.TS_LDKKeysInterface_new(i);
3362 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3364 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3365 if(!isWasmInitialized) {
3366 throw new Error("initializeWasm() must be awaited first!");
3368 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3369 return nativeResponseValue;
3371 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3373 export function KeysInterface_get_destination_script(this_arg: number): number {
3374 if(!isWasmInitialized) {
3375 throw new Error("initializeWasm() must be awaited first!");
3377 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3378 return nativeResponseValue;
3380 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3382 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3383 if(!isWasmInitialized) {
3384 throw new Error("initializeWasm() must be awaited first!");
3386 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3387 return nativeResponseValue;
3389 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3391 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3392 if(!isWasmInitialized) {
3393 throw new Error("initializeWasm() must be awaited first!");
3395 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3396 return nativeResponseValue;
3398 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3400 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3401 if(!isWasmInitialized) {
3402 throw new Error("initializeWasm() must be awaited first!");
3404 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3405 return nativeResponseValue;
3407 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3409 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3410 if(!isWasmInitialized) {
3411 throw new Error("initializeWasm() must be awaited first!");
3413 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3414 return nativeResponseValue;
3416 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3418 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3419 if(!isWasmInitialized) {
3420 throw new Error("initializeWasm() must be awaited first!");
3422 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3423 return nativeResponseValue;
3425 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3427 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3428 if(!isWasmInitialized) {
3429 throw new Error("initializeWasm() must be awaited first!");
3431 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3432 return nativeResponseValue;
3435 export interface LDKFeeEstimator {
3436 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3440 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3441 if(!isWasmInitialized) {
3442 throw new Error("initializeWasm() must be awaited first!");
3444 var new_obj_idx = js_objs.length;
3445 for (var i = 0; i < js_objs.length; i++) {
3446 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3448 js_objs[i] = new WeakRef(impl);
3449 return wasm.TS_LDKFeeEstimator_new(i);
3451 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3453 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3454 if(!isWasmInitialized) {
3455 throw new Error("initializeWasm() must be awaited first!");
3457 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3458 return nativeResponseValue;
3461 export interface LDKLogger {
3462 log (record: number): void;
3466 export function LDKLogger_new(impl: LDKLogger): number {
3467 if(!isWasmInitialized) {
3468 throw new Error("initializeWasm() must be awaited first!");
3470 var new_obj_idx = js_objs.length;
3471 for (var i = 0; i < js_objs.length; i++) {
3472 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3474 js_objs[i] = new WeakRef(impl);
3475 return wasm.TS_LDKLogger_new(i);
3477 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3479 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3480 if(!isWasmInitialized) {
3481 throw new Error("initializeWasm() must be awaited first!");
3483 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3484 return nativeResponseValue;
3486 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3488 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3489 if(!isWasmInitialized) {
3490 throw new Error("initializeWasm() must be awaited first!");
3492 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3493 return nativeResponseValue;
3495 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3497 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3498 if(!isWasmInitialized) {
3499 throw new Error("initializeWasm() must be awaited first!");
3501 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3502 return nativeResponseValue;
3504 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3506 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3507 if(!isWasmInitialized) {
3508 throw new Error("initializeWasm() must be awaited first!");
3510 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3511 return nativeResponseValue;
3513 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3515 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3516 if(!isWasmInitialized) {
3517 throw new Error("initializeWasm() must be awaited first!");
3519 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3520 return nativeResponseValue;
3522 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3524 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3525 if(!isWasmInitialized) {
3526 throw new Error("initializeWasm() must be awaited first!");
3528 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3529 return nativeResponseValue;
3531 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3533 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3534 if(!isWasmInitialized) {
3535 throw new Error("initializeWasm() must be awaited first!");
3537 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3538 return nativeResponseValue;
3540 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3542 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3543 if(!isWasmInitialized) {
3544 throw new Error("initializeWasm() must be awaited first!");
3546 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3547 return nativeResponseValue;
3550 export interface LDKType {
3552 debug_str (): number;
3557 export function LDKType_new(impl: LDKType): number {
3558 if(!isWasmInitialized) {
3559 throw new Error("initializeWasm() must be awaited first!");
3561 var new_obj_idx = js_objs.length;
3562 for (var i = 0; i < js_objs.length; i++) {
3563 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3565 js_objs[i] = new WeakRef(impl);
3566 return wasm.TS_LDKType_new(i);
3568 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
3570 export function Type_type_id(this_arg: number): number {
3571 if(!isWasmInitialized) {
3572 throw new Error("initializeWasm() must be awaited first!");
3574 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
3575 return nativeResponseValue;
3577 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
3579 export function Type_debug_str(this_arg: number): number {
3580 if(!isWasmInitialized) {
3581 throw new Error("initializeWasm() must be awaited first!");
3583 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
3584 return nativeResponseValue;
3586 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
3588 export function Type_write(this_arg: number): number {
3589 if(!isWasmInitialized) {
3590 throw new Error("initializeWasm() must be awaited first!");
3592 const nativeResponseValue = wasm.TS_Type_write(this_arg);
3593 return nativeResponseValue;
3596 export class LDKCOption_TypeZ {
3597 protected constructor() {}
3600 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
3601 if(!isWasmInitialized) {
3602 throw new Error("initializeWasm() must be awaited first!");
3604 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
3605 return nativeResponseValue;
3608 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
3609 if(!isWasmInitialized) {
3610 throw new Error("initializeWasm() must be awaited first!");
3612 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
3613 return nativeResponseValue;
3615 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3617 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
3618 if(!isWasmInitialized) {
3619 throw new Error("initializeWasm() must be awaited first!");
3621 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
3622 return nativeResponseValue;
3624 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3626 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
3627 if(!isWasmInitialized) {
3628 throw new Error("initializeWasm() must be awaited first!");
3630 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
3631 return nativeResponseValue;
3634 export class LDKPaymentError {
3635 protected constructor() {}
3638 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
3639 if(!isWasmInitialized) {
3640 throw new Error("initializeWasm() must be awaited first!");
3642 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
3643 return nativeResponseValue;
3646 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
3647 if(!isWasmInitialized) {
3648 throw new Error("initializeWasm() must be awaited first!");
3650 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
3651 return nativeResponseValue;
3654 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
3655 if(!isWasmInitialized) {
3656 throw new Error("initializeWasm() must be awaited first!");
3658 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
3659 return nativeResponseValue;
3662 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
3663 if(!isWasmInitialized) {
3664 throw new Error("initializeWasm() must be awaited first!");
3666 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
3667 return nativeResponseValue;
3669 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
3671 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
3672 if(!isWasmInitialized) {
3673 throw new Error("initializeWasm() must be awaited first!");
3675 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
3676 return nativeResponseValue;
3678 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
3680 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
3681 if(!isWasmInitialized) {
3682 throw new Error("initializeWasm() must be awaited first!");
3684 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
3685 return nativeResponseValue;
3688 export class LDKParseError {
3689 protected constructor() {}
3692 export function LDKParseError_ty_from_ptr(ptr: number): number {
3693 if(!isWasmInitialized) {
3694 throw new Error("initializeWasm() must be awaited first!");
3696 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
3697 return nativeResponseValue;
3700 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
3701 if(!isWasmInitialized) {
3702 throw new Error("initializeWasm() must be awaited first!");
3704 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
3705 return nativeResponseValue;
3708 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
3709 if(!isWasmInitialized) {
3710 throw new Error("initializeWasm() must be awaited first!");
3712 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
3713 return nativeResponseValue;
3716 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
3717 if(!isWasmInitialized) {
3718 throw new Error("initializeWasm() must be awaited first!");
3720 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
3721 return nativeResponseValue;
3724 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
3725 if(!isWasmInitialized) {
3726 throw new Error("initializeWasm() must be awaited first!");
3728 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
3729 return nativeResponseValue;
3732 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
3733 if(!isWasmInitialized) {
3734 throw new Error("initializeWasm() must be awaited first!");
3736 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
3737 return nativeResponseValue;
3739 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
3741 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
3742 if(!isWasmInitialized) {
3743 throw new Error("initializeWasm() must be awaited first!");
3745 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
3746 return nativeResponseValue;
3748 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
3750 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
3751 if(!isWasmInitialized) {
3752 throw new Error("initializeWasm() must be awaited first!");
3754 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
3755 return nativeResponseValue;
3758 export class LDKParseOrSemanticError {
3759 protected constructor() {}
3762 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
3763 if(!isWasmInitialized) {
3764 throw new Error("initializeWasm() must be awaited first!");
3766 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
3767 return nativeResponseValue;
3770 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
3771 if(!isWasmInitialized) {
3772 throw new Error("initializeWasm() must be awaited first!");
3774 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
3775 return nativeResponseValue;
3778 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
3779 if(!isWasmInitialized) {
3780 throw new Error("initializeWasm() must be awaited first!");
3782 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
3783 return nativeResponseValue;
3785 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
3787 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
3788 if(!isWasmInitialized) {
3789 throw new Error("initializeWasm() must be awaited first!");
3791 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
3792 return nativeResponseValue;
3794 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
3796 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
3797 if(!isWasmInitialized) {
3798 throw new Error("initializeWasm() must be awaited first!");
3800 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
3801 return nativeResponseValue;
3803 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
3805 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
3806 if(!isWasmInitialized) {
3807 throw new Error("initializeWasm() must be awaited first!");
3809 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
3810 return nativeResponseValue;
3812 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
3814 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
3815 if(!isWasmInitialized) {
3816 throw new Error("initializeWasm() must be awaited first!");
3818 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
3819 return nativeResponseValue;
3821 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3823 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
3824 if(!isWasmInitialized) {
3825 throw new Error("initializeWasm() must be awaited first!");
3827 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
3828 return nativeResponseValue;
3830 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3832 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
3833 if(!isWasmInitialized) {
3834 throw new Error("initializeWasm() must be awaited first!");
3836 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
3837 return nativeResponseValue;
3839 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
3841 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
3842 if(!isWasmInitialized) {
3843 throw new Error("initializeWasm() must be awaited first!");
3845 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
3846 return nativeResponseValue;
3848 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
3850 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
3851 if(!isWasmInitialized) {
3852 throw new Error("initializeWasm() must be awaited first!");
3854 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
3855 return nativeResponseValue;
3857 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
3859 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
3860 if(!isWasmInitialized) {
3861 throw new Error("initializeWasm() must be awaited first!");
3863 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
3864 return nativeResponseValue;
3866 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
3868 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
3869 if(!isWasmInitialized) {
3870 throw new Error("initializeWasm() must be awaited first!");
3872 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
3873 return nativeResponseValue;
3875 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
3877 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
3878 if(!isWasmInitialized) {
3879 throw new Error("initializeWasm() must be awaited first!");
3881 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
3882 return nativeResponseValue;
3884 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
3886 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
3887 if(!isWasmInitialized) {
3888 throw new Error("initializeWasm() must be awaited first!");
3890 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
3891 // debug statements here
3893 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
3895 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
3896 if(!isWasmInitialized) {
3897 throw new Error("initializeWasm() must be awaited first!");
3899 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
3900 return nativeResponseValue;
3902 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
3904 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
3905 if(!isWasmInitialized) {
3906 throw new Error("initializeWasm() must be awaited first!");
3908 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
3909 return nativeResponseValue;
3911 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
3913 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
3914 if(!isWasmInitialized) {
3915 throw new Error("initializeWasm() must be awaited first!");
3917 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
3918 return nativeResponseValue;
3920 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
3922 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
3923 if(!isWasmInitialized) {
3924 throw new Error("initializeWasm() must be awaited first!");
3926 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
3927 return nativeResponseValue;
3929 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
3931 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
3932 if(!isWasmInitialized) {
3933 throw new Error("initializeWasm() must be awaited first!");
3935 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
3936 return nativeResponseValue;
3938 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
3940 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
3941 if(!isWasmInitialized) {
3942 throw new Error("initializeWasm() must be awaited first!");
3944 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
3945 return nativeResponseValue;
3947 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
3949 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
3950 if(!isWasmInitialized) {
3951 throw new Error("initializeWasm() must be awaited first!");
3953 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
3954 return nativeResponseValue;
3956 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
3958 export function CResult_StringErrorZ_get_ok(owner: number): number {
3959 if(!isWasmInitialized) {
3960 throw new Error("initializeWasm() must be awaited first!");
3962 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
3963 return nativeResponseValue;
3965 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
3967 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
3968 if(!isWasmInitialized) {
3969 throw new Error("initializeWasm() must be awaited first!");
3971 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
3972 return nativeResponseValue;
3974 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
3976 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
3977 if(!isWasmInitialized) {
3978 throw new Error("initializeWasm() must be awaited first!");
3980 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
3981 return nativeResponseValue;
3983 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
3985 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
3986 if(!isWasmInitialized) {
3987 throw new Error("initializeWasm() must be awaited first!");
3989 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
3990 return nativeResponseValue;
3993 export class LDKCOption_MonitorEventZ {
3994 protected constructor() {}
3997 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
3998 if(!isWasmInitialized) {
3999 throw new Error("initializeWasm() must be awaited first!");
4001 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4002 return nativeResponseValue;
4005 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4006 if(!isWasmInitialized) {
4007 throw new Error("initializeWasm() must be awaited first!");
4009 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4010 return nativeResponseValue;
4012 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4014 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4015 if(!isWasmInitialized) {
4016 throw new Error("initializeWasm() must be awaited first!");
4018 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4019 return nativeResponseValue;
4021 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4023 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4024 if(!isWasmInitialized) {
4025 throw new Error("initializeWasm() must be awaited first!");
4027 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4028 return nativeResponseValue;
4030 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4032 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4033 if(!isWasmInitialized) {
4034 throw new Error("initializeWasm() must be awaited first!");
4036 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4037 return nativeResponseValue;
4039 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4041 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4042 if(!isWasmInitialized) {
4043 throw new Error("initializeWasm() must be awaited first!");
4045 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4046 return nativeResponseValue;
4048 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4050 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4051 if(!isWasmInitialized) {
4052 throw new Error("initializeWasm() must be awaited first!");
4054 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4055 return nativeResponseValue;
4057 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4059 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4060 if(!isWasmInitialized) {
4061 throw new Error("initializeWasm() must be awaited first!");
4063 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4064 return nativeResponseValue;
4066 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4068 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4069 if(!isWasmInitialized) {
4070 throw new Error("initializeWasm() must be awaited first!");
4072 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4073 return nativeResponseValue;
4075 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4077 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4078 if(!isWasmInitialized) {
4079 throw new Error("initializeWasm() must be awaited first!");
4081 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4082 return nativeResponseValue;
4084 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4086 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4087 if(!isWasmInitialized) {
4088 throw new Error("initializeWasm() must be awaited first!");
4090 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4091 return nativeResponseValue;
4093 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4095 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4096 if(!isWasmInitialized) {
4097 throw new Error("initializeWasm() must be awaited first!");
4099 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4100 return nativeResponseValue;
4102 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4104 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4105 if(!isWasmInitialized) {
4106 throw new Error("initializeWasm() must be awaited first!");
4108 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4109 return nativeResponseValue;
4111 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4113 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4114 if(!isWasmInitialized) {
4115 throw new Error("initializeWasm() must be awaited first!");
4117 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4118 return nativeResponseValue;
4120 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4122 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4123 if(!isWasmInitialized) {
4124 throw new Error("initializeWasm() must be awaited first!");
4126 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4127 return nativeResponseValue;
4129 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4131 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4132 if(!isWasmInitialized) {
4133 throw new Error("initializeWasm() must be awaited first!");
4135 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4136 return nativeResponseValue;
4139 export class LDKBalance {
4140 protected constructor() {}
4143 export function LDKBalance_ty_from_ptr(ptr: number): number {
4144 if(!isWasmInitialized) {
4145 throw new Error("initializeWasm() must be awaited first!");
4147 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4148 return nativeResponseValue;
4151 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4152 if(!isWasmInitialized) {
4153 throw new Error("initializeWasm() must be awaited first!");
4155 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4156 return nativeResponseValue;
4159 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4160 if(!isWasmInitialized) {
4161 throw new Error("initializeWasm() must be awaited first!");
4163 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4164 return nativeResponseValue;
4167 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4168 if(!isWasmInitialized) {
4169 throw new Error("initializeWasm() must be awaited first!");
4171 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4172 return nativeResponseValue;
4175 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4176 if(!isWasmInitialized) {
4177 throw new Error("initializeWasm() must be awaited first!");
4179 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4180 return nativeResponseValue;
4183 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4184 if(!isWasmInitialized) {
4185 throw new Error("initializeWasm() must be awaited first!");
4187 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4188 return nativeResponseValue;
4191 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4192 if(!isWasmInitialized) {
4193 throw new Error("initializeWasm() must be awaited first!");
4195 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4196 return nativeResponseValue;
4199 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4200 if(!isWasmInitialized) {
4201 throw new Error("initializeWasm() must be awaited first!");
4203 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4204 return nativeResponseValue;
4206 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4208 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4209 if(!isWasmInitialized) {
4210 throw new Error("initializeWasm() must be awaited first!");
4212 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4213 return nativeResponseValue;
4215 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4217 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4218 if(!isWasmInitialized) {
4219 throw new Error("initializeWasm() must be awaited first!");
4221 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4222 return nativeResponseValue;
4224 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4226 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4227 if(!isWasmInitialized) {
4228 throw new Error("initializeWasm() must be awaited first!");
4230 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4231 return nativeResponseValue;
4233 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4235 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4236 if(!isWasmInitialized) {
4237 throw new Error("initializeWasm() must be awaited first!");
4239 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4240 return nativeResponseValue;
4242 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4244 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
4245 if(!isWasmInitialized) {
4246 throw new Error("initializeWasm() must be awaited first!");
4248 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
4249 // debug statements here
4251 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
4253 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
4254 if(!isWasmInitialized) {
4255 throw new Error("initializeWasm() must be awaited first!");
4257 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
4258 return nativeResponseValue;
4260 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4262 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4263 if(!isWasmInitialized) {
4264 throw new Error("initializeWasm() must be awaited first!");
4266 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4267 return nativeResponseValue;
4269 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4271 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4272 if(!isWasmInitialized) {
4273 throw new Error("initializeWasm() must be awaited first!");
4275 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4276 return nativeResponseValue;
4278 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4280 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
4281 if(!isWasmInitialized) {
4282 throw new Error("initializeWasm() must be awaited first!");
4284 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
4285 return nativeResponseValue;
4287 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
4289 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
4290 if(!isWasmInitialized) {
4291 throw new Error("initializeWasm() must be awaited first!");
4293 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
4294 return nativeResponseValue;
4296 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4298 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
4299 if(!isWasmInitialized) {
4300 throw new Error("initializeWasm() must be awaited first!");
4302 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
4303 return nativeResponseValue;
4305 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4307 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
4308 if(!isWasmInitialized) {
4309 throw new Error("initializeWasm() must be awaited first!");
4311 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
4312 return nativeResponseValue;
4314 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
4316 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
4317 if(!isWasmInitialized) {
4318 throw new Error("initializeWasm() must be awaited first!");
4320 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
4321 return nativeResponseValue;
4324 export class LDKCOption_NetAddressZ {
4325 protected constructor() {}
4328 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4329 if(!isWasmInitialized) {
4330 throw new Error("initializeWasm() must be awaited first!");
4332 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4333 return nativeResponseValue;
4336 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4337 if(!isWasmInitialized) {
4338 throw new Error("initializeWasm() must be awaited first!");
4340 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4341 return nativeResponseValue;
4343 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4345 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4346 if(!isWasmInitialized) {
4347 throw new Error("initializeWasm() must be awaited first!");
4349 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4350 return nativeResponseValue;
4352 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4354 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4355 if(!isWasmInitialized) {
4356 throw new Error("initializeWasm() must be awaited first!");
4358 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4359 return nativeResponseValue;
4361 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4363 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4364 if(!isWasmInitialized) {
4365 throw new Error("initializeWasm() must be awaited first!");
4367 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4368 // debug statements here
4370 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4372 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4373 if(!isWasmInitialized) {
4374 throw new Error("initializeWasm() must be awaited first!");
4376 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4377 return nativeResponseValue;
4379 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4381 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4386 return nativeResponseValue;
4388 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4390 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4391 if(!isWasmInitialized) {
4392 throw new Error("initializeWasm() must be awaited first!");
4394 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4395 return nativeResponseValue;
4397 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4399 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
4400 if(!isWasmInitialized) {
4401 throw new Error("initializeWasm() must be awaited first!");
4403 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
4404 return nativeResponseValue;
4406 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
4408 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
4409 if(!isWasmInitialized) {
4410 throw new Error("initializeWasm() must be awaited first!");
4412 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
4413 return nativeResponseValue;
4415 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4417 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
4418 if(!isWasmInitialized) {
4419 throw new Error("initializeWasm() must be awaited first!");
4421 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
4422 return nativeResponseValue;
4424 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
4426 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
4427 if(!isWasmInitialized) {
4428 throw new Error("initializeWasm() must be awaited first!");
4430 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
4431 return nativeResponseValue;
4434 export interface LDKAccess {
4435 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
4439 export function LDKAccess_new(impl: LDKAccess): number {
4440 if(!isWasmInitialized) {
4441 throw new Error("initializeWasm() must be awaited first!");
4443 var new_obj_idx = js_objs.length;
4444 for (var i = 0; i < js_objs.length; i++) {
4445 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4447 js_objs[i] = new WeakRef(impl);
4448 return wasm.TS_LDKAccess_new(i);
4450 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
4452 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
4453 if(!isWasmInitialized) {
4454 throw new Error("initializeWasm() must be awaited first!");
4456 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
4457 return nativeResponseValue;
4460 export class LDKCOption_AccessZ {
4461 protected constructor() {}
4464 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
4465 if(!isWasmInitialized) {
4466 throw new Error("initializeWasm() must be awaited first!");
4468 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
4469 return nativeResponseValue;
4472 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
4473 if(!isWasmInitialized) {
4474 throw new Error("initializeWasm() must be awaited first!");
4476 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
4477 return nativeResponseValue;
4479 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4481 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
4482 if(!isWasmInitialized) {
4483 throw new Error("initializeWasm() must be awaited first!");
4485 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
4486 return nativeResponseValue;
4488 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
4490 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
4491 if(!isWasmInitialized) {
4492 throw new Error("initializeWasm() must be awaited first!");
4494 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
4495 return nativeResponseValue;
4497 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4499 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
4500 if(!isWasmInitialized) {
4501 throw new Error("initializeWasm() must be awaited first!");
4503 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
4504 return nativeResponseValue;
4506 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
4508 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
4509 if(!isWasmInitialized) {
4510 throw new Error("initializeWasm() must be awaited first!");
4512 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
4513 return nativeResponseValue;
4515 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4517 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
4518 if(!isWasmInitialized) {
4519 throw new Error("initializeWasm() must be awaited first!");
4521 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
4522 return nativeResponseValue;
4524 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
4526 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
4527 if(!isWasmInitialized) {
4528 throw new Error("initializeWasm() must be awaited first!");
4530 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
4531 return nativeResponseValue;
4533 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4535 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
4536 if(!isWasmInitialized) {
4537 throw new Error("initializeWasm() must be awaited first!");
4539 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
4540 return nativeResponseValue;
4542 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
4544 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
4545 if(!isWasmInitialized) {
4546 throw new Error("initializeWasm() must be awaited first!");
4548 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
4549 return nativeResponseValue;
4551 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4553 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
4554 if(!isWasmInitialized) {
4555 throw new Error("initializeWasm() must be awaited first!");
4557 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
4558 return nativeResponseValue;
4560 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
4562 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
4563 if(!isWasmInitialized) {
4564 throw new Error("initializeWasm() must be awaited first!");
4566 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
4567 return nativeResponseValue;
4569 // struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4571 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
4572 if(!isWasmInitialized) {
4573 throw new Error("initializeWasm() must be awaited first!");
4575 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
4576 return nativeResponseValue;
4578 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
4580 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
4581 if(!isWasmInitialized) {
4582 throw new Error("initializeWasm() must be awaited first!");
4584 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
4585 return nativeResponseValue;
4588 export class LDKCOption_CVec_NetAddressZZ {
4589 protected constructor() {}
4592 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
4593 if(!isWasmInitialized) {
4594 throw new Error("initializeWasm() must be awaited first!");
4596 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
4597 return nativeResponseValue;
4600 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
4601 if(!isWasmInitialized) {
4602 throw new Error("initializeWasm() must be awaited first!");
4604 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
4605 return nativeResponseValue;
4607 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4609 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4610 if(!isWasmInitialized) {
4611 throw new Error("initializeWasm() must be awaited first!");
4613 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4614 return nativeResponseValue;
4616 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4618 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4619 if(!isWasmInitialized) {
4620 throw new Error("initializeWasm() must be awaited first!");
4622 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4623 return nativeResponseValue;
4625 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4627 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4628 if(!isWasmInitialized) {
4629 throw new Error("initializeWasm() must be awaited first!");
4631 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4632 return nativeResponseValue;
4634 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4636 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4637 if(!isWasmInitialized) {
4638 throw new Error("initializeWasm() must be awaited first!");
4640 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4641 return nativeResponseValue;
4643 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4645 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4646 if(!isWasmInitialized) {
4647 throw new Error("initializeWasm() must be awaited first!");
4649 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4650 return nativeResponseValue;
4652 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4654 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4655 if(!isWasmInitialized) {
4656 throw new Error("initializeWasm() must be awaited first!");
4658 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4659 return nativeResponseValue;
4661 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4663 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4664 if(!isWasmInitialized) {
4665 throw new Error("initializeWasm() must be awaited first!");
4667 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4668 return nativeResponseValue;
4670 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4672 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4673 if(!isWasmInitialized) {
4674 throw new Error("initializeWasm() must be awaited first!");
4676 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4677 return nativeResponseValue;
4679 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4681 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4682 if(!isWasmInitialized) {
4683 throw new Error("initializeWasm() must be awaited first!");
4685 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4686 return nativeResponseValue;
4688 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4690 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4691 if(!isWasmInitialized) {
4692 throw new Error("initializeWasm() must be awaited first!");
4694 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4695 return nativeResponseValue;
4697 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4699 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4700 if(!isWasmInitialized) {
4701 throw new Error("initializeWasm() must be awaited first!");
4703 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4704 return nativeResponseValue;
4706 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4708 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4709 if(!isWasmInitialized) {
4710 throw new Error("initializeWasm() must be awaited first!");
4712 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4713 return nativeResponseValue;
4715 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4717 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4718 if(!isWasmInitialized) {
4719 throw new Error("initializeWasm() must be awaited first!");
4721 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4722 return nativeResponseValue;
4724 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4726 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4727 if(!isWasmInitialized) {
4728 throw new Error("initializeWasm() must be awaited first!");
4730 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4731 return nativeResponseValue;
4733 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4735 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4736 if(!isWasmInitialized) {
4737 throw new Error("initializeWasm() must be awaited first!");
4739 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4740 return nativeResponseValue;
4742 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4744 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4745 if(!isWasmInitialized) {
4746 throw new Error("initializeWasm() must be awaited first!");
4748 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4749 return nativeResponseValue;
4751 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4753 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4754 if(!isWasmInitialized) {
4755 throw new Error("initializeWasm() must be awaited first!");
4757 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4758 return nativeResponseValue;
4760 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4762 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4763 if(!isWasmInitialized) {
4764 throw new Error("initializeWasm() must be awaited first!");
4766 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4767 return nativeResponseValue;
4769 // struct LDKFundingLocked CResult_FundingLockedDecodeErrorZ_get_ok(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
4771 export function CResult_FundingLockedDecodeErrorZ_get_ok(owner: number): number {
4772 if(!isWasmInitialized) {
4773 throw new Error("initializeWasm() must be awaited first!");
4775 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_ok(owner);
4776 return nativeResponseValue;
4778 // struct LDKDecodeError CResult_FundingLockedDecodeErrorZ_get_err(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR owner);
4780 export function CResult_FundingLockedDecodeErrorZ_get_err(owner: number): number {
4781 if(!isWasmInitialized) {
4782 throw new Error("initializeWasm() must be awaited first!");
4784 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_get_err(owner);
4785 return nativeResponseValue;
4787 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4789 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4790 if(!isWasmInitialized) {
4791 throw new Error("initializeWasm() must be awaited first!");
4793 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4794 return nativeResponseValue;
4796 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4798 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4799 if(!isWasmInitialized) {
4800 throw new Error("initializeWasm() must be awaited first!");
4802 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4803 return nativeResponseValue;
4805 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4807 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
4808 if(!isWasmInitialized) {
4809 throw new Error("initializeWasm() must be awaited first!");
4811 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
4812 return nativeResponseValue;
4814 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4816 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
4817 if(!isWasmInitialized) {
4818 throw new Error("initializeWasm() must be awaited first!");
4820 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
4821 return nativeResponseValue;
4823 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4825 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
4826 if(!isWasmInitialized) {
4827 throw new Error("initializeWasm() must be awaited first!");
4829 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
4830 return nativeResponseValue;
4832 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4834 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
4835 if(!isWasmInitialized) {
4836 throw new Error("initializeWasm() must be awaited first!");
4838 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
4839 return nativeResponseValue;
4841 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4843 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
4844 if(!isWasmInitialized) {
4845 throw new Error("initializeWasm() must be awaited first!");
4847 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
4848 return nativeResponseValue;
4850 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4852 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
4853 if(!isWasmInitialized) {
4854 throw new Error("initializeWasm() must be awaited first!");
4856 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
4857 return nativeResponseValue;
4859 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4861 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
4862 if(!isWasmInitialized) {
4863 throw new Error("initializeWasm() must be awaited first!");
4865 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
4866 return nativeResponseValue;
4868 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4870 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
4871 if(!isWasmInitialized) {
4872 throw new Error("initializeWasm() must be awaited first!");
4874 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
4875 return nativeResponseValue;
4877 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4879 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
4880 if(!isWasmInitialized) {
4881 throw new Error("initializeWasm() must be awaited first!");
4883 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
4884 return nativeResponseValue;
4886 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4888 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
4889 if(!isWasmInitialized) {
4890 throw new Error("initializeWasm() must be awaited first!");
4892 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
4893 return nativeResponseValue;
4895 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
4897 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
4898 if(!isWasmInitialized) {
4899 throw new Error("initializeWasm() must be awaited first!");
4901 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
4902 return nativeResponseValue;
4904 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
4906 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
4907 if(!isWasmInitialized) {
4908 throw new Error("initializeWasm() must be awaited first!");
4910 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
4911 return nativeResponseValue;
4913 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
4915 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
4916 if(!isWasmInitialized) {
4917 throw new Error("initializeWasm() must be awaited first!");
4919 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
4920 return nativeResponseValue;
4922 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
4924 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
4925 if(!isWasmInitialized) {
4926 throw new Error("initializeWasm() must be awaited first!");
4928 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
4929 return nativeResponseValue;
4931 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
4933 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
4934 if(!isWasmInitialized) {
4935 throw new Error("initializeWasm() must be awaited first!");
4937 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
4938 return nativeResponseValue;
4940 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
4942 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
4943 if(!isWasmInitialized) {
4944 throw new Error("initializeWasm() must be awaited first!");
4946 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
4947 return nativeResponseValue;
4949 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
4951 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
4952 if(!isWasmInitialized) {
4953 throw new Error("initializeWasm() must be awaited first!");
4955 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
4956 return nativeResponseValue;
4958 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
4960 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
4961 if(!isWasmInitialized) {
4962 throw new Error("initializeWasm() must be awaited first!");
4964 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
4965 return nativeResponseValue;
4967 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
4969 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
4970 if(!isWasmInitialized) {
4971 throw new Error("initializeWasm() must be awaited first!");
4973 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
4974 return nativeResponseValue;
4976 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
4978 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
4979 if(!isWasmInitialized) {
4980 throw new Error("initializeWasm() must be awaited first!");
4982 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
4983 return nativeResponseValue;
4985 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4987 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
4988 if(!isWasmInitialized) {
4989 throw new Error("initializeWasm() must be awaited first!");
4991 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
4992 return nativeResponseValue;
4994 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
4996 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
4997 if(!isWasmInitialized) {
4998 throw new Error("initializeWasm() must be awaited first!");
5000 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5001 return nativeResponseValue;
5003 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5005 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5006 if(!isWasmInitialized) {
5007 throw new Error("initializeWasm() must be awaited first!");
5009 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5010 return nativeResponseValue;
5012 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5014 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5015 if(!isWasmInitialized) {
5016 throw new Error("initializeWasm() must be awaited first!");
5018 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5019 return nativeResponseValue;
5021 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5023 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5024 if(!isWasmInitialized) {
5025 throw new Error("initializeWasm() must be awaited first!");
5027 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5028 return nativeResponseValue;
5030 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5032 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5033 if(!isWasmInitialized) {
5034 throw new Error("initializeWasm() must be awaited first!");
5036 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5037 return nativeResponseValue;
5039 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5041 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5042 if(!isWasmInitialized) {
5043 throw new Error("initializeWasm() must be awaited first!");
5045 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5046 return nativeResponseValue;
5048 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5050 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5051 if(!isWasmInitialized) {
5052 throw new Error("initializeWasm() must be awaited first!");
5054 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5055 return nativeResponseValue;
5057 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5059 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5060 if(!isWasmInitialized) {
5061 throw new Error("initializeWasm() must be awaited first!");
5063 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5064 return nativeResponseValue;
5066 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5068 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5069 if(!isWasmInitialized) {
5070 throw new Error("initializeWasm() must be awaited first!");
5072 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5073 return nativeResponseValue;
5075 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5077 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5078 if(!isWasmInitialized) {
5079 throw new Error("initializeWasm() must be awaited first!");
5081 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5082 return nativeResponseValue;
5084 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5086 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5087 if(!isWasmInitialized) {
5088 throw new Error("initializeWasm() must be awaited first!");
5090 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5091 return nativeResponseValue;
5093 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5095 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5096 if(!isWasmInitialized) {
5097 throw new Error("initializeWasm() must be awaited first!");
5099 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5100 return nativeResponseValue;
5102 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5104 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5105 if(!isWasmInitialized) {
5106 throw new Error("initializeWasm() must be awaited first!");
5108 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5109 return nativeResponseValue;
5111 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5113 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5114 if(!isWasmInitialized) {
5115 throw new Error("initializeWasm() must be awaited first!");
5117 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5118 return nativeResponseValue;
5120 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5122 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5123 if(!isWasmInitialized) {
5124 throw new Error("initializeWasm() must be awaited first!");
5126 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5127 return nativeResponseValue;
5129 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5131 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5132 if(!isWasmInitialized) {
5133 throw new Error("initializeWasm() must be awaited first!");
5135 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5136 return nativeResponseValue;
5138 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5140 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5141 if(!isWasmInitialized) {
5142 throw new Error("initializeWasm() must be awaited first!");
5144 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5145 return nativeResponseValue;
5147 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5149 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5150 if(!isWasmInitialized) {
5151 throw new Error("initializeWasm() must be awaited first!");
5153 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5154 return nativeResponseValue;
5156 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5158 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5159 if(!isWasmInitialized) {
5160 throw new Error("initializeWasm() must be awaited first!");
5162 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5163 return nativeResponseValue;
5165 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5167 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5168 if(!isWasmInitialized) {
5169 throw new Error("initializeWasm() must be awaited first!");
5171 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5172 return nativeResponseValue;
5174 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5176 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5177 if(!isWasmInitialized) {
5178 throw new Error("initializeWasm() must be awaited first!");
5180 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5181 return nativeResponseValue;
5183 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5185 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5186 if(!isWasmInitialized) {
5187 throw new Error("initializeWasm() must be awaited first!");
5189 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5190 return nativeResponseValue;
5192 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5194 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5195 if(!isWasmInitialized) {
5196 throw new Error("initializeWasm() must be awaited first!");
5198 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5199 return nativeResponseValue;
5201 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5203 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5204 if(!isWasmInitialized) {
5205 throw new Error("initializeWasm() must be awaited first!");
5207 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5208 return nativeResponseValue;
5210 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5212 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5213 if(!isWasmInitialized) {
5214 throw new Error("initializeWasm() must be awaited first!");
5216 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5217 return nativeResponseValue;
5220 export class LDKSignOrCreationError {
5221 protected constructor() {}
5224 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5225 if(!isWasmInitialized) {
5226 throw new Error("initializeWasm() must be awaited first!");
5228 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5229 return nativeResponseValue;
5232 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5233 if(!isWasmInitialized) {
5234 throw new Error("initializeWasm() must be awaited first!");
5236 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5237 return nativeResponseValue;
5239 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5241 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5242 if(!isWasmInitialized) {
5243 throw new Error("initializeWasm() must be awaited first!");
5245 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5246 return nativeResponseValue;
5248 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5250 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5251 if(!isWasmInitialized) {
5252 throw new Error("initializeWasm() must be awaited first!");
5254 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5255 return nativeResponseValue;
5258 export interface LDKFilter {
5259 register_tx (txid: number, script_pubkey: number): void;
5260 register_output (output: number): number;
5264 export function LDKFilter_new(impl: LDKFilter): number {
5265 if(!isWasmInitialized) {
5266 throw new Error("initializeWasm() must be awaited first!");
5268 var new_obj_idx = js_objs.length;
5269 for (var i = 0; i < js_objs.length; i++) {
5270 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5272 js_objs[i] = new WeakRef(impl);
5273 return wasm.TS_LDKFilter_new(i);
5275 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5277 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5278 if(!isWasmInitialized) {
5279 throw new Error("initializeWasm() must be awaited first!");
5281 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5282 // debug statements here
5284 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5286 export function Filter_register_output(this_arg: number, output: number): number {
5287 if(!isWasmInitialized) {
5288 throw new Error("initializeWasm() must be awaited first!");
5290 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5291 return nativeResponseValue;
5294 export class LDKCOption_FilterZ {
5295 protected constructor() {}
5298 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5299 if(!isWasmInitialized) {
5300 throw new Error("initializeWasm() must be awaited first!");
5302 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5303 return nativeResponseValue;
5306 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5307 if(!isWasmInitialized) {
5308 throw new Error("initializeWasm() must be awaited first!");
5310 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5311 return nativeResponseValue;
5313 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5315 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5316 if(!isWasmInitialized) {
5317 throw new Error("initializeWasm() must be awaited first!");
5319 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5320 return nativeResponseValue;
5322 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5324 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5325 if(!isWasmInitialized) {
5326 throw new Error("initializeWasm() must be awaited first!");
5328 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5329 // debug statements here
5332 export interface LDKMessageSendEventsProvider {
5333 get_and_clear_pending_msg_events (): number;
5337 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5338 if(!isWasmInitialized) {
5339 throw new Error("initializeWasm() must be awaited first!");
5341 var new_obj_idx = js_objs.length;
5342 for (var i = 0; i < js_objs.length; i++) {
5343 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5345 js_objs[i] = new WeakRef(impl);
5346 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5348 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5350 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5351 if(!isWasmInitialized) {
5352 throw new Error("initializeWasm() must be awaited first!");
5354 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5355 return nativeResponseValue;
5358 export interface LDKEventHandler {
5359 handle_event (event: number): void;
5363 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5364 if(!isWasmInitialized) {
5365 throw new Error("initializeWasm() must be awaited first!");
5367 var new_obj_idx = js_objs.length;
5368 for (var i = 0; i < js_objs.length; i++) {
5369 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5371 js_objs[i] = new WeakRef(impl);
5372 return wasm.TS_LDKEventHandler_new(i);
5374 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5376 export function EventHandler_handle_event(this_arg: number, event: number): void {
5377 if(!isWasmInitialized) {
5378 throw new Error("initializeWasm() must be awaited first!");
5380 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5381 // debug statements here
5384 export interface LDKEventsProvider {
5385 process_pending_events (handler: number): void;
5389 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5390 if(!isWasmInitialized) {
5391 throw new Error("initializeWasm() must be awaited first!");
5393 var new_obj_idx = js_objs.length;
5394 for (var i = 0; i < js_objs.length; i++) {
5395 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5397 js_objs[i] = new WeakRef(impl);
5398 return wasm.TS_LDKEventsProvider_new(i);
5400 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5402 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5403 if(!isWasmInitialized) {
5404 throw new Error("initializeWasm() must be awaited first!");
5406 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5407 // debug statements here
5410 export interface LDKListen {
5411 block_connected (block: number, height: number): void;
5412 block_disconnected (header: number, height: number): void;
5416 export function LDKListen_new(impl: LDKListen): number {
5417 if(!isWasmInitialized) {
5418 throw new Error("initializeWasm() must be awaited first!");
5420 var new_obj_idx = js_objs.length;
5421 for (var i = 0; i < js_objs.length; i++) {
5422 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5424 js_objs[i] = new WeakRef(impl);
5425 return wasm.TS_LDKListen_new(i);
5427 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5429 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5430 if(!isWasmInitialized) {
5431 throw new Error("initializeWasm() must be awaited first!");
5433 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5434 // debug statements here
5436 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5438 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5439 if(!isWasmInitialized) {
5440 throw new Error("initializeWasm() must be awaited first!");
5442 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5443 // debug statements here
5446 export interface LDKConfirm {
5447 transactions_confirmed (header: number, txdata: number, height: number): void;
5448 transaction_unconfirmed (txid: number): void;
5449 best_block_updated (header: number, height: number): void;
5450 get_relevant_txids (): number;
5454 export function LDKConfirm_new(impl: LDKConfirm): number {
5455 if(!isWasmInitialized) {
5456 throw new Error("initializeWasm() must be awaited first!");
5458 var new_obj_idx = js_objs.length;
5459 for (var i = 0; i < js_objs.length; i++) {
5460 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5462 js_objs[i] = new WeakRef(impl);
5463 return wasm.TS_LDKConfirm_new(i);
5465 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5467 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5468 if(!isWasmInitialized) {
5469 throw new Error("initializeWasm() must be awaited first!");
5471 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5472 // debug statements here
5474 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5476 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5477 if(!isWasmInitialized) {
5478 throw new Error("initializeWasm() must be awaited first!");
5480 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5481 // debug statements here
5483 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5485 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5486 if(!isWasmInitialized) {
5487 throw new Error("initializeWasm() must be awaited first!");
5489 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5490 // debug statements here
5492 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5494 export function Confirm_get_relevant_txids(this_arg: number): number {
5495 if(!isWasmInitialized) {
5496 throw new Error("initializeWasm() must be awaited first!");
5498 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5499 return nativeResponseValue;
5502 export interface LDKPersist {
5503 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5504 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5508 export function LDKPersist_new(impl: LDKPersist): number {
5509 if(!isWasmInitialized) {
5510 throw new Error("initializeWasm() must be awaited first!");
5512 var new_obj_idx = js_objs.length;
5513 for (var i = 0; i < js_objs.length; i++) {
5514 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5516 js_objs[i] = new WeakRef(impl);
5517 return wasm.TS_LDKPersist_new(i);
5519 // 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
5521 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5522 if(!isWasmInitialized) {
5523 throw new Error("initializeWasm() must be awaited first!");
5525 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5526 return nativeResponseValue;
5528 // 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
5530 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5531 if(!isWasmInitialized) {
5532 throw new Error("initializeWasm() must be awaited first!");
5534 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5535 return nativeResponseValue;
5538 export interface LDKChannelMessageHandler {
5539 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5540 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5541 handle_funding_created (their_node_id: number, msg: number): void;
5542 handle_funding_signed (their_node_id: number, msg: number): void;
5543 handle_funding_locked (their_node_id: number, msg: number): void;
5544 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5545 handle_closing_signed (their_node_id: number, msg: number): void;
5546 handle_update_add_htlc (their_node_id: number, msg: number): void;
5547 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5548 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5549 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5550 handle_commitment_signed (their_node_id: number, msg: number): void;
5551 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5552 handle_update_fee (their_node_id: number, msg: number): void;
5553 handle_announcement_signatures (their_node_id: number, msg: number): void;
5554 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5555 peer_connected (their_node_id: number, msg: number): void;
5556 handle_channel_reestablish (their_node_id: number, msg: number): void;
5557 handle_channel_update (their_node_id: number, msg: number): void;
5558 handle_error (their_node_id: number, msg: number): void;
5562 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5563 if(!isWasmInitialized) {
5564 throw new Error("initializeWasm() must be awaited first!");
5566 var new_obj_idx = js_objs.length;
5567 for (var i = 0; i < js_objs.length; i++) {
5568 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5570 js_objs[i] = new WeakRef(impl);
5571 return wasm.TS_LDKChannelMessageHandler_new(i);
5573 // 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
5575 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5576 if(!isWasmInitialized) {
5577 throw new Error("initializeWasm() must be awaited first!");
5579 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5580 // debug statements here
5582 // 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
5584 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5585 if(!isWasmInitialized) {
5586 throw new Error("initializeWasm() must be awaited first!");
5588 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
5589 // debug statements here
5591 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5593 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
5594 if(!isWasmInitialized) {
5595 throw new Error("initializeWasm() must be awaited first!");
5597 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
5598 // debug statements here
5600 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5602 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
5603 if(!isWasmInitialized) {
5604 throw new Error("initializeWasm() must be awaited first!");
5606 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
5607 // debug statements here
5609 // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
5611 export function ChannelMessageHandler_handle_funding_locked(this_arg: number, their_node_id: number, msg: number): void {
5612 if(!isWasmInitialized) {
5613 throw new Error("initializeWasm() must be awaited first!");
5615 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_locked(this_arg, their_node_id, msg);
5616 // debug statements here
5618 // 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
5620 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5621 if(!isWasmInitialized) {
5622 throw new Error("initializeWasm() must be awaited first!");
5624 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5625 // debug statements here
5627 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5629 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
5630 if(!isWasmInitialized) {
5631 throw new Error("initializeWasm() must be awaited first!");
5633 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
5634 // debug statements here
5636 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5638 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
5639 if(!isWasmInitialized) {
5640 throw new Error("initializeWasm() must be awaited first!");
5642 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
5643 // debug statements here
5645 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5647 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
5648 if(!isWasmInitialized) {
5649 throw new Error("initializeWasm() must be awaited first!");
5651 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
5652 // debug statements here
5654 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5656 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
5657 if(!isWasmInitialized) {
5658 throw new Error("initializeWasm() must be awaited first!");
5660 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
5661 // debug statements here
5663 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5665 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
5666 if(!isWasmInitialized) {
5667 throw new Error("initializeWasm() must be awaited first!");
5669 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5670 // debug statements here
5672 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5674 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5675 if(!isWasmInitialized) {
5676 throw new Error("initializeWasm() must be awaited first!");
5678 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5679 // debug statements here
5681 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5683 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
5684 if(!isWasmInitialized) {
5685 throw new Error("initializeWasm() must be awaited first!");
5687 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
5688 // debug statements here
5690 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5692 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
5693 if(!isWasmInitialized) {
5694 throw new Error("initializeWasm() must be awaited first!");
5696 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
5697 // debug statements here
5699 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
5701 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
5702 if(!isWasmInitialized) {
5703 throw new Error("initializeWasm() must be awaited first!");
5705 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
5706 // debug statements here
5708 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
5710 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
5711 if(!isWasmInitialized) {
5712 throw new Error("initializeWasm() must be awaited first!");
5714 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
5715 // debug statements here
5717 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
5719 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
5720 if(!isWasmInitialized) {
5721 throw new Error("initializeWasm() must be awaited first!");
5723 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
5724 // debug statements here
5726 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
5728 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
5729 if(!isWasmInitialized) {
5730 throw new Error("initializeWasm() must be awaited first!");
5732 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
5733 // debug statements here
5735 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
5737 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
5738 if(!isWasmInitialized) {
5739 throw new Error("initializeWasm() must be awaited first!");
5741 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
5742 // debug statements here
5744 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
5746 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
5747 if(!isWasmInitialized) {
5748 throw new Error("initializeWasm() must be awaited first!");
5750 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
5751 // debug statements here
5754 export interface LDKRoutingMessageHandler {
5755 handle_node_announcement (msg: number): number;
5756 handle_channel_announcement (msg: number): number;
5757 handle_channel_update (msg: number): number;
5758 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
5759 get_next_node_announcements (starting_point: number, batch_amount: number): number;
5760 peer_connected (their_node_id: number, init: number): void;
5761 handle_reply_channel_range (their_node_id: number, msg: number): number;
5762 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
5763 handle_query_channel_range (their_node_id: number, msg: number): number;
5764 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
5768 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5769 if(!isWasmInitialized) {
5770 throw new Error("initializeWasm() must be awaited first!");
5772 var new_obj_idx = js_objs.length;
5773 for (var i = 0; i < js_objs.length; i++) {
5774 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5776 js_objs[i] = new WeakRef(impl);
5777 return wasm.TS_LDKRoutingMessageHandler_new(i);
5779 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
5781 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
5782 if(!isWasmInitialized) {
5783 throw new Error("initializeWasm() must be awaited first!");
5785 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
5786 return nativeResponseValue;
5788 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
5790 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
5791 if(!isWasmInitialized) {
5792 throw new Error("initializeWasm() must be awaited first!");
5794 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
5795 return nativeResponseValue;
5797 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
5799 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
5800 if(!isWasmInitialized) {
5801 throw new Error("initializeWasm() must be awaited first!");
5803 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
5804 return nativeResponseValue;
5806 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
5808 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
5809 if(!isWasmInitialized) {
5810 throw new Error("initializeWasm() must be awaited first!");
5812 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
5813 return nativeResponseValue;
5815 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
5817 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
5818 if(!isWasmInitialized) {
5819 throw new Error("initializeWasm() must be awaited first!");
5821 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
5822 return nativeResponseValue;
5824 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
5826 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
5827 if(!isWasmInitialized) {
5828 throw new Error("initializeWasm() must be awaited first!");
5830 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
5831 // debug statements here
5833 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
5835 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5836 if(!isWasmInitialized) {
5837 throw new Error("initializeWasm() must be awaited first!");
5839 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
5840 return nativeResponseValue;
5842 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
5844 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
5845 if(!isWasmInitialized) {
5846 throw new Error("initializeWasm() must be awaited first!");
5848 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
5849 return nativeResponseValue;
5851 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
5853 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
5854 if(!isWasmInitialized) {
5855 throw new Error("initializeWasm() must be awaited first!");
5857 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
5858 return nativeResponseValue;
5860 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
5862 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
5863 if(!isWasmInitialized) {
5864 throw new Error("initializeWasm() must be awaited first!");
5866 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
5867 return nativeResponseValue;
5870 export interface LDKCustomMessageReader {
5871 read (message_type: number, buffer: number): number;
5875 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
5876 if(!isWasmInitialized) {
5877 throw new Error("initializeWasm() must be awaited first!");
5879 var new_obj_idx = js_objs.length;
5880 for (var i = 0; i < js_objs.length; i++) {
5881 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5883 js_objs[i] = new WeakRef(impl);
5884 return wasm.TS_LDKCustomMessageReader_new(i);
5886 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
5888 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
5889 if(!isWasmInitialized) {
5890 throw new Error("initializeWasm() must be awaited first!");
5892 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
5893 return nativeResponseValue;
5896 export interface LDKCustomMessageHandler {
5897 handle_custom_message (msg: number, sender_node_id: number): number;
5898 get_and_clear_pending_msg (): number;
5902 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
5903 if(!isWasmInitialized) {
5904 throw new Error("initializeWasm() must be awaited first!");
5906 var new_obj_idx = js_objs.length;
5907 for (var i = 0; i < js_objs.length; i++) {
5908 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5910 js_objs[i] = new WeakRef(impl);
5911 return wasm.TS_LDKCustomMessageHandler_new(i);
5913 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
5915 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
5916 if(!isWasmInitialized) {
5917 throw new Error("initializeWasm() must be awaited first!");
5919 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
5920 return nativeResponseValue;
5922 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
5924 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
5925 if(!isWasmInitialized) {
5926 throw new Error("initializeWasm() must be awaited first!");
5928 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
5929 return nativeResponseValue;
5932 export interface LDKSocketDescriptor {
5933 send_data (data: number, resume_read: boolean): number;
5934 disconnect_socket (): void;
5935 eq (other_arg: number): boolean;
5940 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
5941 if(!isWasmInitialized) {
5942 throw new Error("initializeWasm() must be awaited first!");
5944 var new_obj_idx = js_objs.length;
5945 for (var i = 0; i < js_objs.length; i++) {
5946 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5948 js_objs[i] = new WeakRef(impl);
5949 return wasm.TS_LDKSocketDescriptor_new(i);
5951 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
5953 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
5954 if(!isWasmInitialized) {
5955 throw new Error("initializeWasm() must be awaited first!");
5957 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
5958 return nativeResponseValue;
5960 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
5962 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
5963 if(!isWasmInitialized) {
5964 throw new Error("initializeWasm() must be awaited first!");
5966 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
5967 // debug statements here
5969 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
5971 export function SocketDescriptor_hash(this_arg: number): bigint {
5972 if(!isWasmInitialized) {
5973 throw new Error("initializeWasm() must be awaited first!");
5975 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
5976 return nativeResponseValue;
5979 export class LDKEffectiveCapacity {
5980 protected constructor() {}
5983 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
5984 if(!isWasmInitialized) {
5985 throw new Error("initializeWasm() must be awaited first!");
5987 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
5988 return nativeResponseValue;
5991 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
5992 if(!isWasmInitialized) {
5993 throw new Error("initializeWasm() must be awaited first!");
5995 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
5996 return nativeResponseValue;
5999 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6004 return nativeResponseValue;
6007 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6008 if(!isWasmInitialized) {
6009 throw new Error("initializeWasm() must be awaited first!");
6011 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6012 return nativeResponseValue;
6015 export interface LDKScore {
6016 channel_penalty_msat (short_channel_id: bigint, send_amt_msat: bigint, capacity_msat: bigint, source: number, target: number): bigint;
6017 payment_path_failed (path: number, short_channel_id: bigint): void;
6018 payment_path_successful (path: number): void;
6023 export function LDKScore_new(impl: LDKScore): number {
6024 if(!isWasmInitialized) {
6025 throw new Error("initializeWasm() must be awaited first!");
6027 var new_obj_idx = js_objs.length;
6028 for (var i = 0; i < js_objs.length; i++) {
6029 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6031 js_objs[i] = new WeakRef(impl);
6032 return wasm.TS_LDKScore_new(i);
6034 // uint64_t Score_channel_penalty_msat LDKScore *NONNULL_PTR this_arg, uint64_t short_channel_id, uint64_t send_amt_msat, uint64_t capacity_msat, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target
6036 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, send_amt_msat: bigint, capacity_msat: bigint, source: number, target: number): bigint {
6037 if(!isWasmInitialized) {
6038 throw new Error("initializeWasm() must be awaited first!");
6040 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, send_amt_msat, capacity_msat, source, target);
6041 return nativeResponseValue;
6043 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
6045 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
6046 if(!isWasmInitialized) {
6047 throw new Error("initializeWasm() must be awaited first!");
6049 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
6050 // debug statements here
6052 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
6054 export function Score_payment_path_successful(this_arg: number, path: number): void {
6055 if(!isWasmInitialized) {
6056 throw new Error("initializeWasm() must be awaited first!");
6058 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
6059 // debug statements here
6061 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
6063 export function Score_write(this_arg: number): number {
6064 if(!isWasmInitialized) {
6065 throw new Error("initializeWasm() must be awaited first!");
6067 const nativeResponseValue = wasm.TS_Score_write(this_arg);
6068 return nativeResponseValue;
6071 export interface LDKLockableScore {
6076 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6077 if(!isWasmInitialized) {
6078 throw new Error("initializeWasm() must be awaited first!");
6080 var new_obj_idx = js_objs.length;
6081 for (var i = 0; i < js_objs.length; i++) {
6082 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6084 js_objs[i] = new WeakRef(impl);
6085 return wasm.TS_LDKLockableScore_new(i);
6087 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6089 export function LockableScore_lock(this_arg: number): number {
6090 if(!isWasmInitialized) {
6091 throw new Error("initializeWasm() must be awaited first!");
6093 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6094 return nativeResponseValue;
6097 export class LDKFallback {
6098 protected constructor() {}
6101 export function LDKFallback_ty_from_ptr(ptr: number): number {
6102 if(!isWasmInitialized) {
6103 throw new Error("initializeWasm() must be awaited first!");
6105 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6106 return nativeResponseValue;
6109 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6110 if(!isWasmInitialized) {
6111 throw new Error("initializeWasm() must be awaited first!");
6113 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6114 return nativeResponseValue;
6117 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6118 if(!isWasmInitialized) {
6119 throw new Error("initializeWasm() must be awaited first!");
6121 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6122 return nativeResponseValue;
6125 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6126 if(!isWasmInitialized) {
6127 throw new Error("initializeWasm() must be awaited first!");
6129 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6130 return nativeResponseValue;
6133 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6134 if(!isWasmInitialized) {
6135 throw new Error("initializeWasm() must be awaited first!");
6137 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6138 return nativeResponseValue;
6141 export interface LDKPayer {
6143 first_hops (): number;
6144 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6145 send_spontaneous_payment (route: number, payment_preimage: number): number;
6146 retry_payment (route: number, payment_id: number): number;
6147 abandon_payment (payment_id: number): void;
6151 export function LDKPayer_new(impl: LDKPayer): number {
6152 if(!isWasmInitialized) {
6153 throw new Error("initializeWasm() must be awaited first!");
6155 var new_obj_idx = js_objs.length;
6156 for (var i = 0; i < js_objs.length; i++) {
6157 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6159 js_objs[i] = new WeakRef(impl);
6160 return wasm.TS_LDKPayer_new(i);
6162 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6164 export function Payer_node_id(this_arg: number): number {
6165 if(!isWasmInitialized) {
6166 throw new Error("initializeWasm() must be awaited first!");
6168 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6169 return nativeResponseValue;
6171 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6173 export function Payer_first_hops(this_arg: number): number {
6174 if(!isWasmInitialized) {
6175 throw new Error("initializeWasm() must be awaited first!");
6177 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6178 return nativeResponseValue;
6180 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6182 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6183 if(!isWasmInitialized) {
6184 throw new Error("initializeWasm() must be awaited first!");
6186 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6187 return nativeResponseValue;
6189 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6191 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6192 if(!isWasmInitialized) {
6193 throw new Error("initializeWasm() must be awaited first!");
6195 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6196 return nativeResponseValue;
6198 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6200 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6201 if(!isWasmInitialized) {
6202 throw new Error("initializeWasm() must be awaited first!");
6204 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6205 return nativeResponseValue;
6207 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6209 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6210 if(!isWasmInitialized) {
6211 throw new Error("initializeWasm() must be awaited first!");
6213 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6214 // debug statements here
6217 export interface LDKRouter {
6218 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6222 export function LDKRouter_new(impl: LDKRouter): number {
6223 if(!isWasmInitialized) {
6224 throw new Error("initializeWasm() must be awaited first!");
6226 var new_obj_idx = js_objs.length;
6227 for (var i = 0; i < js_objs.length; i++) {
6228 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6230 js_objs[i] = new WeakRef(impl);
6231 return wasm.TS_LDKRouter_new(i);
6233 // 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
6235 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6236 if(!isWasmInitialized) {
6237 throw new Error("initializeWasm() must be awaited first!");
6239 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6240 return nativeResponseValue;
6242 // struct LDKStr _ldk_get_compiled_version(void);
6244 export function _ldk_get_compiled_version(): number {
6245 if(!isWasmInitialized) {
6246 throw new Error("initializeWasm() must be awaited first!");
6248 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6249 return nativeResponseValue;
6251 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6253 export function _ldk_c_bindings_get_compiled_version(): number {
6254 if(!isWasmInitialized) {
6255 throw new Error("initializeWasm() must be awaited first!");
6257 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6258 return nativeResponseValue;
6260 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6262 export function Bech32Error_clone_ptr(arg: number): number {
6263 if(!isWasmInitialized) {
6264 throw new Error("initializeWasm() must be awaited first!");
6266 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6267 return nativeResponseValue;
6269 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6271 export function Bech32Error_clone(orig: number): number {
6272 if(!isWasmInitialized) {
6273 throw new Error("initializeWasm() must be awaited first!");
6275 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6276 return nativeResponseValue;
6278 // void Bech32Error_free(struct LDKBech32Error o);
6280 export function Bech32Error_free(o: number): void {
6281 if(!isWasmInitialized) {
6282 throw new Error("initializeWasm() must be awaited first!");
6284 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6285 // debug statements here
6287 // void Transaction_free(struct LDKTransaction _res);
6289 export function Transaction_free(_res: number): void {
6290 if(!isWasmInitialized) {
6291 throw new Error("initializeWasm() must be awaited first!");
6293 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6294 // debug statements here
6296 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6298 export function TxOut_new(script_pubkey: number, value: bigint): number {
6299 if(!isWasmInitialized) {
6300 throw new Error("initializeWasm() must be awaited first!");
6302 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6303 return nativeResponseValue;
6305 // void TxOut_free(struct LDKTxOut _res);
6307 export function TxOut_free(_res: number): void {
6308 if(!isWasmInitialized) {
6309 throw new Error("initializeWasm() must be awaited first!");
6311 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6312 // debug statements here
6314 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6316 export function TxOut_clone_ptr(arg: number): number {
6317 if(!isWasmInitialized) {
6318 throw new Error("initializeWasm() must be awaited first!");
6320 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6321 return nativeResponseValue;
6323 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6325 export function TxOut_clone(orig: number): number {
6326 if(!isWasmInitialized) {
6327 throw new Error("initializeWasm() must be awaited first!");
6329 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6330 return nativeResponseValue;
6332 // void Str_free(struct LDKStr _res);
6334 export function Str_free(_res: number): void {
6335 if(!isWasmInitialized) {
6336 throw new Error("initializeWasm() must be awaited first!");
6338 const nativeResponseValue = wasm.TS_Str_free(_res);
6339 // debug statements here
6341 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6343 export function CResult_NoneNoneZ_ok(): number {
6344 if(!isWasmInitialized) {
6345 throw new Error("initializeWasm() must be awaited first!");
6347 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6348 return nativeResponseValue;
6350 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6352 export function CResult_NoneNoneZ_err(): number {
6353 if(!isWasmInitialized) {
6354 throw new Error("initializeWasm() must be awaited first!");
6356 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6357 return nativeResponseValue;
6359 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6361 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6362 if(!isWasmInitialized) {
6363 throw new Error("initializeWasm() must be awaited first!");
6365 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6366 return nativeResponseValue;
6368 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6370 export function CResult_NoneNoneZ_free(_res: number): void {
6371 if(!isWasmInitialized) {
6372 throw new Error("initializeWasm() must be awaited first!");
6374 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6375 // debug statements here
6377 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6379 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6380 if(!isWasmInitialized) {
6381 throw new Error("initializeWasm() must be awaited first!");
6383 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6384 return nativeResponseValue;
6386 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6388 export function CResult_NoneNoneZ_clone(orig: number): number {
6389 if(!isWasmInitialized) {
6390 throw new Error("initializeWasm() must be awaited first!");
6392 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6393 return nativeResponseValue;
6395 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6397 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6398 if(!isWasmInitialized) {
6399 throw new Error("initializeWasm() must be awaited first!");
6401 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6402 return nativeResponseValue;
6404 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6406 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6407 if(!isWasmInitialized) {
6408 throw new Error("initializeWasm() must be awaited first!");
6410 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6411 return nativeResponseValue;
6413 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6415 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6416 if(!isWasmInitialized) {
6417 throw new Error("initializeWasm() must be awaited first!");
6419 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6420 return nativeResponseValue;
6422 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6424 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6425 if(!isWasmInitialized) {
6426 throw new Error("initializeWasm() must be awaited first!");
6428 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6429 // debug statements here
6431 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6433 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6434 if(!isWasmInitialized) {
6435 throw new Error("initializeWasm() must be awaited first!");
6437 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6438 return nativeResponseValue;
6440 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6442 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6443 if(!isWasmInitialized) {
6444 throw new Error("initializeWasm() must be awaited first!");
6446 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6447 return nativeResponseValue;
6449 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6451 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6452 if(!isWasmInitialized) {
6453 throw new Error("initializeWasm() must be awaited first!");
6455 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6456 return nativeResponseValue;
6458 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6460 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6461 if(!isWasmInitialized) {
6462 throw new Error("initializeWasm() must be awaited first!");
6464 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6465 return nativeResponseValue;
6467 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6469 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6470 if(!isWasmInitialized) {
6471 throw new Error("initializeWasm() must be awaited first!");
6473 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6474 return nativeResponseValue;
6476 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6478 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6479 if(!isWasmInitialized) {
6480 throw new Error("initializeWasm() must be awaited first!");
6482 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6483 // debug statements here
6485 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6487 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6488 if(!isWasmInitialized) {
6489 throw new Error("initializeWasm() must be awaited first!");
6491 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6492 return nativeResponseValue;
6494 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6496 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6497 if(!isWasmInitialized) {
6498 throw new Error("initializeWasm() must be awaited first!");
6500 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6501 return nativeResponseValue;
6503 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6505 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6506 if(!isWasmInitialized) {
6507 throw new Error("initializeWasm() must be awaited first!");
6509 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6510 return nativeResponseValue;
6512 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6514 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6515 if(!isWasmInitialized) {
6516 throw new Error("initializeWasm() must be awaited first!");
6518 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6519 return nativeResponseValue;
6521 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6523 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6524 if(!isWasmInitialized) {
6525 throw new Error("initializeWasm() must be awaited first!");
6527 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6528 return nativeResponseValue;
6530 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6532 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6533 if(!isWasmInitialized) {
6534 throw new Error("initializeWasm() must be awaited first!");
6536 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6537 // debug statements here
6539 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6541 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6542 if(!isWasmInitialized) {
6543 throw new Error("initializeWasm() must be awaited first!");
6545 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6546 return nativeResponseValue;
6548 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6550 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6551 if(!isWasmInitialized) {
6552 throw new Error("initializeWasm() must be awaited first!");
6554 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6555 return nativeResponseValue;
6557 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6559 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6560 if(!isWasmInitialized) {
6561 throw new Error("initializeWasm() must be awaited first!");
6563 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6564 return nativeResponseValue;
6566 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6568 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6569 if(!isWasmInitialized) {
6570 throw new Error("initializeWasm() must be awaited first!");
6572 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6573 return nativeResponseValue;
6575 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6577 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6578 if(!isWasmInitialized) {
6579 throw new Error("initializeWasm() must be awaited first!");
6581 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6582 return nativeResponseValue;
6584 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6586 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6587 if(!isWasmInitialized) {
6588 throw new Error("initializeWasm() must be awaited first!");
6590 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6591 // debug statements here
6593 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6595 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6596 if(!isWasmInitialized) {
6597 throw new Error("initializeWasm() must be awaited first!");
6599 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6600 return nativeResponseValue;
6602 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6604 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6605 if(!isWasmInitialized) {
6606 throw new Error("initializeWasm() must be awaited first!");
6608 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6609 return nativeResponseValue;
6611 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6613 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6614 if(!isWasmInitialized) {
6615 throw new Error("initializeWasm() must be awaited first!");
6617 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6618 return nativeResponseValue;
6620 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6622 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6623 if(!isWasmInitialized) {
6624 throw new Error("initializeWasm() must be awaited first!");
6626 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6627 return nativeResponseValue;
6629 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6631 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6632 if(!isWasmInitialized) {
6633 throw new Error("initializeWasm() must be awaited first!");
6635 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6636 return nativeResponseValue;
6638 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6640 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6641 if(!isWasmInitialized) {
6642 throw new Error("initializeWasm() must be awaited first!");
6644 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6645 // debug statements here
6647 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6649 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6650 if(!isWasmInitialized) {
6651 throw new Error("initializeWasm() must be awaited first!");
6653 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6654 return nativeResponseValue;
6656 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6658 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6659 if(!isWasmInitialized) {
6660 throw new Error("initializeWasm() must be awaited first!");
6662 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6663 return nativeResponseValue;
6665 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6667 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6668 if(!isWasmInitialized) {
6669 throw new Error("initializeWasm() must be awaited first!");
6671 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6672 return nativeResponseValue;
6674 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6676 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6677 if(!isWasmInitialized) {
6678 throw new Error("initializeWasm() must be awaited first!");
6680 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6681 return nativeResponseValue;
6683 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6685 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6686 if(!isWasmInitialized) {
6687 throw new Error("initializeWasm() must be awaited first!");
6689 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6690 return nativeResponseValue;
6692 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6694 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6695 if(!isWasmInitialized) {
6696 throw new Error("initializeWasm() must be awaited first!");
6698 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6699 // debug statements here
6701 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6703 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6704 if(!isWasmInitialized) {
6705 throw new Error("initializeWasm() must be awaited first!");
6707 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6708 return nativeResponseValue;
6710 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6712 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6713 if(!isWasmInitialized) {
6714 throw new Error("initializeWasm() must be awaited first!");
6716 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6717 return nativeResponseValue;
6719 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
6721 export function COption_u32Z_some(o: number): number {
6722 if(!isWasmInitialized) {
6723 throw new Error("initializeWasm() must be awaited first!");
6725 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
6726 return nativeResponseValue;
6728 // struct LDKCOption_u32Z COption_u32Z_none(void);
6730 export function COption_u32Z_none(): number {
6731 if(!isWasmInitialized) {
6732 throw new Error("initializeWasm() must be awaited first!");
6734 const nativeResponseValue = wasm.TS_COption_u32Z_none();
6735 return nativeResponseValue;
6737 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
6739 export function COption_u32Z_free(_res: number): void {
6740 if(!isWasmInitialized) {
6741 throw new Error("initializeWasm() must be awaited first!");
6743 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
6744 // debug statements here
6746 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
6748 export function COption_u32Z_clone_ptr(arg: number): number {
6749 if(!isWasmInitialized) {
6750 throw new Error("initializeWasm() must be awaited first!");
6752 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
6753 return nativeResponseValue;
6755 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
6757 export function COption_u32Z_clone(orig: number): number {
6758 if(!isWasmInitialized) {
6759 throw new Error("initializeWasm() must be awaited first!");
6761 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
6762 return nativeResponseValue;
6764 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
6766 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
6767 if(!isWasmInitialized) {
6768 throw new Error("initializeWasm() must be awaited first!");
6770 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
6771 return nativeResponseValue;
6773 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
6775 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
6776 if(!isWasmInitialized) {
6777 throw new Error("initializeWasm() must be awaited first!");
6779 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
6780 return nativeResponseValue;
6782 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
6784 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
6785 if(!isWasmInitialized) {
6786 throw new Error("initializeWasm() must be awaited first!");
6788 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
6789 return nativeResponseValue;
6791 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
6793 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
6794 if(!isWasmInitialized) {
6795 throw new Error("initializeWasm() must be awaited first!");
6797 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
6798 // debug statements here
6800 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
6802 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
6803 if(!isWasmInitialized) {
6804 throw new Error("initializeWasm() must be awaited first!");
6806 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
6807 return nativeResponseValue;
6809 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
6811 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
6812 if(!isWasmInitialized) {
6813 throw new Error("initializeWasm() must be awaited first!");
6815 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
6816 return nativeResponseValue;
6818 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
6820 export function COption_NoneZ_some(): COption_NoneZ {
6821 if(!isWasmInitialized) {
6822 throw new Error("initializeWasm() must be awaited first!");
6824 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
6825 return nativeResponseValue;
6827 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
6829 export function COption_NoneZ_none(): COption_NoneZ {
6830 if(!isWasmInitialized) {
6831 throw new Error("initializeWasm() must be awaited first!");
6833 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
6834 return nativeResponseValue;
6836 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
6838 export function COption_NoneZ_free(_res: COption_NoneZ): void {
6839 if(!isWasmInitialized) {
6840 throw new Error("initializeWasm() must be awaited first!");
6842 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
6843 // debug statements here
6845 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
6847 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
6848 if(!isWasmInitialized) {
6849 throw new Error("initializeWasm() must be awaited first!");
6851 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
6852 return nativeResponseValue;
6854 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
6856 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
6857 if(!isWasmInitialized) {
6858 throw new Error("initializeWasm() must be awaited first!");
6860 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
6861 return nativeResponseValue;
6863 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
6865 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
6866 if(!isWasmInitialized) {
6867 throw new Error("initializeWasm() must be awaited first!");
6869 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
6870 return nativeResponseValue;
6872 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
6874 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
6875 if(!isWasmInitialized) {
6876 throw new Error("initializeWasm() must be awaited first!");
6878 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
6879 // debug statements here
6881 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
6883 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
6884 if(!isWasmInitialized) {
6885 throw new Error("initializeWasm() must be awaited first!");
6887 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
6888 return nativeResponseValue;
6890 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
6892 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
6893 if(!isWasmInitialized) {
6894 throw new Error("initializeWasm() must be awaited first!");
6896 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
6897 return nativeResponseValue;
6899 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
6901 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
6902 if(!isWasmInitialized) {
6903 throw new Error("initializeWasm() must be awaited first!");
6905 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
6906 return nativeResponseValue;
6908 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
6910 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
6911 if(!isWasmInitialized) {
6912 throw new Error("initializeWasm() must be awaited first!");
6914 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
6915 return nativeResponseValue;
6917 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
6919 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
6920 if(!isWasmInitialized) {
6921 throw new Error("initializeWasm() must be awaited first!");
6923 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
6924 return nativeResponseValue;
6926 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
6928 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
6929 if(!isWasmInitialized) {
6930 throw new Error("initializeWasm() must be awaited first!");
6932 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
6933 // debug statements here
6935 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
6937 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
6938 if(!isWasmInitialized) {
6939 throw new Error("initializeWasm() must be awaited first!");
6941 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
6942 return nativeResponseValue;
6944 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
6946 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
6947 if(!isWasmInitialized) {
6948 throw new Error("initializeWasm() must be awaited first!");
6950 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
6951 return nativeResponseValue;
6953 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
6955 export function CVec_SignatureZ_free(_res: number): void {
6956 if(!isWasmInitialized) {
6957 throw new Error("initializeWasm() must be awaited first!");
6959 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
6960 // debug statements here
6962 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
6964 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
6965 if(!isWasmInitialized) {
6966 throw new Error("initializeWasm() must be awaited first!");
6968 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
6969 return nativeResponseValue;
6971 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
6973 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
6974 if(!isWasmInitialized) {
6975 throw new Error("initializeWasm() must be awaited first!");
6977 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
6978 return nativeResponseValue;
6980 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
6982 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
6983 if(!isWasmInitialized) {
6984 throw new Error("initializeWasm() must be awaited first!");
6986 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
6987 return nativeResponseValue;
6989 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
6991 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
6992 if(!isWasmInitialized) {
6993 throw new Error("initializeWasm() must be awaited first!");
6995 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
6996 // debug statements here
6998 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7000 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7001 if(!isWasmInitialized) {
7002 throw new Error("initializeWasm() must be awaited first!");
7004 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7005 return nativeResponseValue;
7007 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7009 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7010 if(!isWasmInitialized) {
7011 throw new Error("initializeWasm() must be awaited first!");
7013 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7014 return nativeResponseValue;
7016 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7018 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7019 if(!isWasmInitialized) {
7020 throw new Error("initializeWasm() must be awaited first!");
7022 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7023 return nativeResponseValue;
7025 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7027 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7028 if(!isWasmInitialized) {
7029 throw new Error("initializeWasm() must be awaited first!");
7031 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7032 return nativeResponseValue;
7034 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7036 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7037 if(!isWasmInitialized) {
7038 throw new Error("initializeWasm() must be awaited first!");
7040 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7041 return nativeResponseValue;
7043 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7045 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7046 if(!isWasmInitialized) {
7047 throw new Error("initializeWasm() must be awaited first!");
7049 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7050 // debug statements here
7052 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7054 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7055 if(!isWasmInitialized) {
7056 throw new Error("initializeWasm() must be awaited first!");
7058 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7059 return nativeResponseValue;
7061 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7063 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7064 if(!isWasmInitialized) {
7065 throw new Error("initializeWasm() must be awaited first!");
7067 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7068 return nativeResponseValue;
7070 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7072 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7073 if(!isWasmInitialized) {
7074 throw new Error("initializeWasm() must be awaited first!");
7076 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7077 return nativeResponseValue;
7079 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7081 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7082 if(!isWasmInitialized) {
7083 throw new Error("initializeWasm() must be awaited first!");
7085 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7086 return nativeResponseValue;
7088 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7090 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7091 if(!isWasmInitialized) {
7092 throw new Error("initializeWasm() must be awaited first!");
7094 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7095 return nativeResponseValue;
7097 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7099 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7100 if(!isWasmInitialized) {
7101 throw new Error("initializeWasm() must be awaited first!");
7103 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7104 // debug statements here
7106 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7108 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7109 if(!isWasmInitialized) {
7110 throw new Error("initializeWasm() must be awaited first!");
7112 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7113 return nativeResponseValue;
7115 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7117 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7118 if(!isWasmInitialized) {
7119 throw new Error("initializeWasm() must be awaited first!");
7121 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7122 return nativeResponseValue;
7124 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7126 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7127 if(!isWasmInitialized) {
7128 throw new Error("initializeWasm() must be awaited first!");
7130 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7131 return nativeResponseValue;
7133 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7135 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7136 if(!isWasmInitialized) {
7137 throw new Error("initializeWasm() must be awaited first!");
7139 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7140 // debug statements here
7142 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7144 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7145 if(!isWasmInitialized) {
7146 throw new Error("initializeWasm() must be awaited first!");
7148 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7149 return nativeResponseValue;
7151 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7153 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7154 if(!isWasmInitialized) {
7155 throw new Error("initializeWasm() must be awaited first!");
7157 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7158 return nativeResponseValue;
7160 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7162 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7163 if(!isWasmInitialized) {
7164 throw new Error("initializeWasm() must be awaited first!");
7166 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7167 return nativeResponseValue;
7169 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7171 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7172 if(!isWasmInitialized) {
7173 throw new Error("initializeWasm() must be awaited first!");
7175 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7176 return nativeResponseValue;
7178 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7180 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7181 if(!isWasmInitialized) {
7182 throw new Error("initializeWasm() must be awaited first!");
7184 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7185 return nativeResponseValue;
7187 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7189 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7190 if(!isWasmInitialized) {
7191 throw new Error("initializeWasm() must be awaited first!");
7193 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7194 // debug statements here
7196 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7198 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7199 if(!isWasmInitialized) {
7200 throw new Error("initializeWasm() must be awaited first!");
7202 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7203 return nativeResponseValue;
7205 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7207 export function CResult_CVec_SignatureZNoneZ_err(): number {
7208 if(!isWasmInitialized) {
7209 throw new Error("initializeWasm() must be awaited first!");
7211 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7212 return nativeResponseValue;
7214 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7216 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7217 if(!isWasmInitialized) {
7218 throw new Error("initializeWasm() must be awaited first!");
7220 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7221 return nativeResponseValue;
7223 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7225 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7226 if(!isWasmInitialized) {
7227 throw new Error("initializeWasm() must be awaited first!");
7229 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7230 // debug statements here
7232 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7234 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7235 if(!isWasmInitialized) {
7236 throw new Error("initializeWasm() must be awaited first!");
7238 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7239 return nativeResponseValue;
7241 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7243 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7244 if(!isWasmInitialized) {
7245 throw new Error("initializeWasm() must be awaited first!");
7247 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7248 return nativeResponseValue;
7250 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7252 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7253 if(!isWasmInitialized) {
7254 throw new Error("initializeWasm() must be awaited first!");
7256 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7257 return nativeResponseValue;
7259 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7261 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7262 if(!isWasmInitialized) {
7263 throw new Error("initializeWasm() must be awaited first!");
7265 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7266 return nativeResponseValue;
7268 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7270 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7271 if(!isWasmInitialized) {
7272 throw new Error("initializeWasm() must be awaited first!");
7274 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7275 return nativeResponseValue;
7277 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7279 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7280 if(!isWasmInitialized) {
7281 throw new Error("initializeWasm() must be awaited first!");
7283 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7284 // debug statements here
7286 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7288 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7289 if(!isWasmInitialized) {
7290 throw new Error("initializeWasm() must be awaited first!");
7292 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7293 return nativeResponseValue;
7295 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7297 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7298 if(!isWasmInitialized) {
7299 throw new Error("initializeWasm() must be awaited first!");
7301 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7302 return nativeResponseValue;
7304 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7306 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7307 if(!isWasmInitialized) {
7308 throw new Error("initializeWasm() must be awaited first!");
7310 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7311 return nativeResponseValue;
7313 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7315 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7316 if(!isWasmInitialized) {
7317 throw new Error("initializeWasm() must be awaited first!");
7319 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7320 return nativeResponseValue;
7322 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7324 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7325 if(!isWasmInitialized) {
7326 throw new Error("initializeWasm() must be awaited first!");
7328 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7329 return nativeResponseValue;
7331 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7333 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7334 if(!isWasmInitialized) {
7335 throw new Error("initializeWasm() must be awaited first!");
7337 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7338 // debug statements here
7340 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7342 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7343 if(!isWasmInitialized) {
7344 throw new Error("initializeWasm() must be awaited first!");
7346 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7347 return nativeResponseValue;
7349 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7351 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7352 if(!isWasmInitialized) {
7353 throw new Error("initializeWasm() must be awaited first!");
7355 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7356 return nativeResponseValue;
7358 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7360 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7361 if(!isWasmInitialized) {
7362 throw new Error("initializeWasm() must be awaited first!");
7364 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7365 return nativeResponseValue;
7367 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7369 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7370 if(!isWasmInitialized) {
7371 throw new Error("initializeWasm() must be awaited first!");
7373 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7374 return nativeResponseValue;
7376 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7378 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7379 if(!isWasmInitialized) {
7380 throw new Error("initializeWasm() must be awaited first!");
7382 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7383 return nativeResponseValue;
7385 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7387 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7388 if(!isWasmInitialized) {
7389 throw new Error("initializeWasm() must be awaited first!");
7391 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7392 // debug statements here
7394 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7396 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7397 if(!isWasmInitialized) {
7398 throw new Error("initializeWasm() must be awaited first!");
7400 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7401 return nativeResponseValue;
7403 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7405 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7406 if(!isWasmInitialized) {
7407 throw new Error("initializeWasm() must be awaited first!");
7409 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7410 return nativeResponseValue;
7412 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7414 export function CVec_RouteHopZ_free(_res: number): void {
7415 if(!isWasmInitialized) {
7416 throw new Error("initializeWasm() must be awaited first!");
7418 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7419 // debug statements here
7421 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7423 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7424 if(!isWasmInitialized) {
7425 throw new Error("initializeWasm() must be awaited first!");
7427 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7428 // debug statements here
7430 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7432 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7433 if(!isWasmInitialized) {
7434 throw new Error("initializeWasm() must be awaited first!");
7436 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7437 return nativeResponseValue;
7439 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7441 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7442 if(!isWasmInitialized) {
7443 throw new Error("initializeWasm() must be awaited first!");
7445 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7446 return nativeResponseValue;
7448 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7450 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7451 if(!isWasmInitialized) {
7452 throw new Error("initializeWasm() must be awaited first!");
7454 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7455 return nativeResponseValue;
7457 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7459 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7460 if(!isWasmInitialized) {
7461 throw new Error("initializeWasm() must be awaited first!");
7463 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7464 // debug statements here
7466 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7468 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7469 if(!isWasmInitialized) {
7470 throw new Error("initializeWasm() must be awaited first!");
7472 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7473 return nativeResponseValue;
7475 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7477 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7478 if(!isWasmInitialized) {
7479 throw new Error("initializeWasm() must be awaited first!");
7481 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7482 return nativeResponseValue;
7484 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7486 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7487 if(!isWasmInitialized) {
7488 throw new Error("initializeWasm() must be awaited first!");
7490 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7491 return nativeResponseValue;
7493 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7495 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7496 if(!isWasmInitialized) {
7497 throw new Error("initializeWasm() must be awaited first!");
7499 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7500 return nativeResponseValue;
7502 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7504 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7505 if(!isWasmInitialized) {
7506 throw new Error("initializeWasm() must be awaited first!");
7508 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7509 return nativeResponseValue;
7511 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7513 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7514 if(!isWasmInitialized) {
7515 throw new Error("initializeWasm() must be awaited first!");
7517 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7518 // debug statements here
7520 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7522 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7523 if(!isWasmInitialized) {
7524 throw new Error("initializeWasm() must be awaited first!");
7526 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7527 return nativeResponseValue;
7529 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7531 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7532 if(!isWasmInitialized) {
7533 throw new Error("initializeWasm() must be awaited first!");
7535 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7536 return nativeResponseValue;
7538 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7540 export function CVec_RouteHintZ_free(_res: number): void {
7541 if(!isWasmInitialized) {
7542 throw new Error("initializeWasm() must be awaited first!");
7544 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7545 // debug statements here
7547 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7549 export function COption_u64Z_some(o: bigint): number {
7550 if(!isWasmInitialized) {
7551 throw new Error("initializeWasm() must be awaited first!");
7553 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7554 return nativeResponseValue;
7556 // struct LDKCOption_u64Z COption_u64Z_none(void);
7558 export function COption_u64Z_none(): number {
7559 if(!isWasmInitialized) {
7560 throw new Error("initializeWasm() must be awaited first!");
7562 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7563 return nativeResponseValue;
7565 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7567 export function COption_u64Z_free(_res: number): void {
7568 if(!isWasmInitialized) {
7569 throw new Error("initializeWasm() must be awaited first!");
7571 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7572 // debug statements here
7574 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7576 export function COption_u64Z_clone_ptr(arg: number): number {
7577 if(!isWasmInitialized) {
7578 throw new Error("initializeWasm() must be awaited first!");
7580 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7581 return nativeResponseValue;
7583 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7585 export function COption_u64Z_clone(orig: number): number {
7586 if(!isWasmInitialized) {
7587 throw new Error("initializeWasm() must be awaited first!");
7589 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7590 return nativeResponseValue;
7592 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7594 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7595 if(!isWasmInitialized) {
7596 throw new Error("initializeWasm() must be awaited first!");
7598 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7599 return nativeResponseValue;
7601 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7603 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7604 if(!isWasmInitialized) {
7605 throw new Error("initializeWasm() must be awaited first!");
7607 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7608 return nativeResponseValue;
7610 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7612 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7613 if(!isWasmInitialized) {
7614 throw new Error("initializeWasm() must be awaited first!");
7616 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7617 return nativeResponseValue;
7619 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7621 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7626 // debug statements here
7628 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7630 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7631 if(!isWasmInitialized) {
7632 throw new Error("initializeWasm() must be awaited first!");
7634 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7635 return nativeResponseValue;
7637 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7639 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7640 if(!isWasmInitialized) {
7641 throw new Error("initializeWasm() must be awaited first!");
7643 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7644 return nativeResponseValue;
7646 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7648 export function CVec_RouteHintHopZ_free(_res: number): void {
7649 if(!isWasmInitialized) {
7650 throw new Error("initializeWasm() must be awaited first!");
7652 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7653 // debug statements here
7655 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7657 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7658 if(!isWasmInitialized) {
7659 throw new Error("initializeWasm() must be awaited first!");
7661 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7662 return nativeResponseValue;
7664 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7666 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7667 if(!isWasmInitialized) {
7668 throw new Error("initializeWasm() must be awaited first!");
7670 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7671 return nativeResponseValue;
7673 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7675 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7676 if(!isWasmInitialized) {
7677 throw new Error("initializeWasm() must be awaited first!");
7679 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7680 return nativeResponseValue;
7682 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7684 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7685 if(!isWasmInitialized) {
7686 throw new Error("initializeWasm() must be awaited first!");
7688 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7689 // debug statements here
7691 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7693 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7694 if(!isWasmInitialized) {
7695 throw new Error("initializeWasm() must be awaited first!");
7697 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7698 return nativeResponseValue;
7700 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7702 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7703 if(!isWasmInitialized) {
7704 throw new Error("initializeWasm() must be awaited first!");
7706 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7707 return nativeResponseValue;
7709 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7711 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7712 if(!isWasmInitialized) {
7713 throw new Error("initializeWasm() must be awaited first!");
7715 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7716 return nativeResponseValue;
7718 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7720 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7721 if(!isWasmInitialized) {
7722 throw new Error("initializeWasm() must be awaited first!");
7724 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7725 return nativeResponseValue;
7727 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7729 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7730 if(!isWasmInitialized) {
7731 throw new Error("initializeWasm() must be awaited first!");
7733 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7734 return nativeResponseValue;
7736 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7738 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7739 if(!isWasmInitialized) {
7740 throw new Error("initializeWasm() must be awaited first!");
7742 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7743 // debug statements here
7745 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7747 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7748 if(!isWasmInitialized) {
7749 throw new Error("initializeWasm() must be awaited first!");
7751 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7752 return nativeResponseValue;
7754 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7756 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7757 if(!isWasmInitialized) {
7758 throw new Error("initializeWasm() must be awaited first!");
7760 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7761 return nativeResponseValue;
7763 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7765 export function CVec_ChannelDetailsZ_free(_res: number): void {
7766 if(!isWasmInitialized) {
7767 throw new Error("initializeWasm() must be awaited first!");
7769 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7770 // debug statements here
7772 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7774 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7775 if(!isWasmInitialized) {
7776 throw new Error("initializeWasm() must be awaited first!");
7778 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7779 return nativeResponseValue;
7781 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7783 export function CResult_RouteLightningErrorZ_err(e: number): number {
7784 if(!isWasmInitialized) {
7785 throw new Error("initializeWasm() must be awaited first!");
7787 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7788 return nativeResponseValue;
7790 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7792 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7793 if(!isWasmInitialized) {
7794 throw new Error("initializeWasm() must be awaited first!");
7796 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7797 return nativeResponseValue;
7799 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7801 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7802 if(!isWasmInitialized) {
7803 throw new Error("initializeWasm() must be awaited first!");
7805 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7806 // debug statements here
7808 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7810 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7811 if(!isWasmInitialized) {
7812 throw new Error("initializeWasm() must be awaited first!");
7814 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
7815 return nativeResponseValue;
7817 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
7819 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
7820 if(!isWasmInitialized) {
7821 throw new Error("initializeWasm() must be awaited first!");
7823 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
7824 return nativeResponseValue;
7826 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
7828 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
7829 if(!isWasmInitialized) {
7830 throw new Error("initializeWasm() must be awaited first!");
7832 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
7833 return nativeResponseValue;
7835 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
7837 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
7838 if(!isWasmInitialized) {
7839 throw new Error("initializeWasm() must be awaited first!");
7841 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
7842 return nativeResponseValue;
7844 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
7846 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
7847 if(!isWasmInitialized) {
7848 throw new Error("initializeWasm() must be awaited first!");
7850 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
7851 return nativeResponseValue;
7853 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
7855 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
7856 if(!isWasmInitialized) {
7857 throw new Error("initializeWasm() must be awaited first!");
7859 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
7860 // debug statements here
7862 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
7864 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
7865 if(!isWasmInitialized) {
7866 throw new Error("initializeWasm() must be awaited first!");
7868 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
7869 return nativeResponseValue;
7871 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
7873 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
7874 if(!isWasmInitialized) {
7875 throw new Error("initializeWasm() must be awaited first!");
7877 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
7878 return nativeResponseValue;
7880 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
7882 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
7883 if(!isWasmInitialized) {
7884 throw new Error("initializeWasm() must be awaited first!");
7886 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
7887 return nativeResponseValue;
7889 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
7891 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
7892 if(!isWasmInitialized) {
7893 throw new Error("initializeWasm() must be awaited first!");
7895 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
7896 return nativeResponseValue;
7898 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
7900 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
7905 return nativeResponseValue;
7907 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
7909 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
7914 // debug statements here
7916 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
7918 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
7919 if(!isWasmInitialized) {
7920 throw new Error("initializeWasm() must be awaited first!");
7922 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
7923 // debug statements here
7925 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
7927 export function CVec_TxidZ_free(_res: number): void {
7928 if(!isWasmInitialized) {
7929 throw new Error("initializeWasm() must be awaited first!");
7931 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
7932 // debug statements here
7934 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
7936 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
7937 if(!isWasmInitialized) {
7938 throw new Error("initializeWasm() must be awaited first!");
7940 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
7941 return nativeResponseValue;
7943 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
7945 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
7946 if(!isWasmInitialized) {
7947 throw new Error("initializeWasm() must be awaited first!");
7949 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
7950 return nativeResponseValue;
7952 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
7954 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
7955 if(!isWasmInitialized) {
7956 throw new Error("initializeWasm() must be awaited first!");
7958 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
7959 return nativeResponseValue;
7961 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
7963 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
7964 if(!isWasmInitialized) {
7965 throw new Error("initializeWasm() must be awaited first!");
7967 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
7968 // debug statements here
7970 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
7972 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
7973 if(!isWasmInitialized) {
7974 throw new Error("initializeWasm() must be awaited first!");
7976 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
7977 return nativeResponseValue;
7979 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
7981 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
7982 if(!isWasmInitialized) {
7983 throw new Error("initializeWasm() must be awaited first!");
7985 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
7986 return nativeResponseValue;
7988 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
7990 export function CVec_MonitorEventZ_free(_res: number): void {
7991 if(!isWasmInitialized) {
7992 throw new Error("initializeWasm() must be awaited first!");
7994 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
7995 // debug statements here
7997 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
7999 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8000 if(!isWasmInitialized) {
8001 throw new Error("initializeWasm() must be awaited first!");
8003 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8004 return nativeResponseValue;
8006 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8008 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8009 if(!isWasmInitialized) {
8010 throw new Error("initializeWasm() must be awaited first!");
8012 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8013 return nativeResponseValue;
8015 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8017 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8018 if(!isWasmInitialized) {
8019 throw new Error("initializeWasm() must be awaited first!");
8021 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8022 // debug statements here
8024 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8026 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8027 if(!isWasmInitialized) {
8028 throw new Error("initializeWasm() must be awaited first!");
8030 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8031 return nativeResponseValue;
8033 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8035 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8036 if(!isWasmInitialized) {
8037 throw new Error("initializeWasm() must be awaited first!");
8039 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8040 return nativeResponseValue;
8042 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8044 export function COption_ClosureReasonZ_some(o: number): number {
8045 if(!isWasmInitialized) {
8046 throw new Error("initializeWasm() must be awaited first!");
8048 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8049 return nativeResponseValue;
8051 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8053 export function COption_ClosureReasonZ_none(): number {
8054 if(!isWasmInitialized) {
8055 throw new Error("initializeWasm() must be awaited first!");
8057 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8058 return nativeResponseValue;
8060 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8062 export function COption_ClosureReasonZ_free(_res: number): void {
8063 if(!isWasmInitialized) {
8064 throw new Error("initializeWasm() must be awaited first!");
8066 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8067 // debug statements here
8069 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8071 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8072 if(!isWasmInitialized) {
8073 throw new Error("initializeWasm() must be awaited first!");
8075 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8076 return nativeResponseValue;
8078 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8080 export function COption_ClosureReasonZ_clone(orig: number): number {
8081 if(!isWasmInitialized) {
8082 throw new Error("initializeWasm() must be awaited first!");
8084 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8085 return nativeResponseValue;
8087 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8089 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8090 if(!isWasmInitialized) {
8091 throw new Error("initializeWasm() must be awaited first!");
8093 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8094 return nativeResponseValue;
8096 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8098 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8099 if(!isWasmInitialized) {
8100 throw new Error("initializeWasm() must be awaited first!");
8102 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8103 return nativeResponseValue;
8105 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8107 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8108 if(!isWasmInitialized) {
8109 throw new Error("initializeWasm() must be awaited first!");
8111 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8112 return nativeResponseValue;
8114 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8116 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8117 if(!isWasmInitialized) {
8118 throw new Error("initializeWasm() must be awaited first!");
8120 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8121 // debug statements here
8123 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8125 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8126 if(!isWasmInitialized) {
8127 throw new Error("initializeWasm() must be awaited first!");
8129 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8130 return nativeResponseValue;
8132 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8134 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8135 if(!isWasmInitialized) {
8136 throw new Error("initializeWasm() must be awaited first!");
8138 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8139 return nativeResponseValue;
8141 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8143 export function COption_NetworkUpdateZ_some(o: number): number {
8144 if(!isWasmInitialized) {
8145 throw new Error("initializeWasm() must be awaited first!");
8147 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8148 return nativeResponseValue;
8150 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8152 export function COption_NetworkUpdateZ_none(): number {
8153 if(!isWasmInitialized) {
8154 throw new Error("initializeWasm() must be awaited first!");
8156 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8157 return nativeResponseValue;
8159 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8161 export function COption_NetworkUpdateZ_free(_res: number): void {
8162 if(!isWasmInitialized) {
8163 throw new Error("initializeWasm() must be awaited first!");
8165 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8166 // debug statements here
8168 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8170 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8171 if(!isWasmInitialized) {
8172 throw new Error("initializeWasm() must be awaited first!");
8174 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8175 return nativeResponseValue;
8177 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8179 export function COption_NetworkUpdateZ_clone(orig: number): number {
8180 if(!isWasmInitialized) {
8181 throw new Error("initializeWasm() must be awaited first!");
8183 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8184 return nativeResponseValue;
8186 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8188 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8189 if(!isWasmInitialized) {
8190 throw new Error("initializeWasm() must be awaited first!");
8192 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8193 // debug statements here
8195 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8197 export function COption_EventZ_some(o: number): number {
8198 if(!isWasmInitialized) {
8199 throw new Error("initializeWasm() must be awaited first!");
8201 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8202 return nativeResponseValue;
8204 // struct LDKCOption_EventZ COption_EventZ_none(void);
8206 export function COption_EventZ_none(): number {
8207 if(!isWasmInitialized) {
8208 throw new Error("initializeWasm() must be awaited first!");
8210 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8211 return nativeResponseValue;
8213 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8215 export function COption_EventZ_free(_res: number): void {
8216 if(!isWasmInitialized) {
8217 throw new Error("initializeWasm() must be awaited first!");
8219 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8220 // debug statements here
8222 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8224 export function COption_EventZ_clone_ptr(arg: number): number {
8225 if(!isWasmInitialized) {
8226 throw new Error("initializeWasm() must be awaited first!");
8228 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8229 return nativeResponseValue;
8231 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8233 export function COption_EventZ_clone(orig: number): number {
8234 if(!isWasmInitialized) {
8235 throw new Error("initializeWasm() must be awaited first!");
8237 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8238 return nativeResponseValue;
8240 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8242 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8243 if(!isWasmInitialized) {
8244 throw new Error("initializeWasm() must be awaited first!");
8246 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8247 return nativeResponseValue;
8249 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8251 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8252 if(!isWasmInitialized) {
8253 throw new Error("initializeWasm() must be awaited first!");
8255 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8256 return nativeResponseValue;
8258 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8260 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8261 if(!isWasmInitialized) {
8262 throw new Error("initializeWasm() must be awaited first!");
8264 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8265 return nativeResponseValue;
8267 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8269 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8270 if(!isWasmInitialized) {
8271 throw new Error("initializeWasm() must be awaited first!");
8273 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8274 // debug statements here
8276 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8278 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8279 if(!isWasmInitialized) {
8280 throw new Error("initializeWasm() must be awaited first!");
8282 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8283 return nativeResponseValue;
8285 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8287 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8288 if(!isWasmInitialized) {
8289 throw new Error("initializeWasm() must be awaited first!");
8291 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8292 return nativeResponseValue;
8294 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8296 export function CVec_MessageSendEventZ_free(_res: number): void {
8297 if(!isWasmInitialized) {
8298 throw new Error("initializeWasm() must be awaited first!");
8300 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8301 // debug statements here
8303 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8305 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8306 if(!isWasmInitialized) {
8307 throw new Error("initializeWasm() must be awaited first!");
8309 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8310 return nativeResponseValue;
8312 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8314 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8315 if(!isWasmInitialized) {
8316 throw new Error("initializeWasm() must be awaited first!");
8318 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8319 return nativeResponseValue;
8321 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8323 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8324 if(!isWasmInitialized) {
8325 throw new Error("initializeWasm() must be awaited first!");
8327 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8328 return nativeResponseValue;
8330 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8332 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8333 if(!isWasmInitialized) {
8334 throw new Error("initializeWasm() must be awaited first!");
8336 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8337 // debug statements here
8339 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8341 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8342 if(!isWasmInitialized) {
8343 throw new Error("initializeWasm() must be awaited first!");
8345 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8346 return nativeResponseValue;
8348 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8350 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8351 if(!isWasmInitialized) {
8352 throw new Error("initializeWasm() must be awaited first!");
8354 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8355 return nativeResponseValue;
8357 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_ok(struct LDKScoringParameters o);
8359 export function CResult_ScoringParametersDecodeErrorZ_ok(o: number): number {
8360 if(!isWasmInitialized) {
8361 throw new Error("initializeWasm() must be awaited first!");
8363 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_ok(o);
8364 return nativeResponseValue;
8366 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_err(struct LDKDecodeError e);
8368 export function CResult_ScoringParametersDecodeErrorZ_err(e: number): number {
8369 if(!isWasmInitialized) {
8370 throw new Error("initializeWasm() must be awaited first!");
8372 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_err(e);
8373 return nativeResponseValue;
8375 // bool CResult_ScoringParametersDecodeErrorZ_is_ok(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR o);
8377 export function CResult_ScoringParametersDecodeErrorZ_is_ok(o: number): boolean {
8378 if(!isWasmInitialized) {
8379 throw new Error("initializeWasm() must be awaited first!");
8381 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_is_ok(o);
8382 return nativeResponseValue;
8384 // void CResult_ScoringParametersDecodeErrorZ_free(struct LDKCResult_ScoringParametersDecodeErrorZ _res);
8386 export function CResult_ScoringParametersDecodeErrorZ_free(_res: number): void {
8387 if(!isWasmInitialized) {
8388 throw new Error("initializeWasm() must be awaited first!");
8390 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_free(_res);
8391 // debug statements here
8393 // uintptr_t CResult_ScoringParametersDecodeErrorZ_clone_ptr(LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR arg);
8395 export function CResult_ScoringParametersDecodeErrorZ_clone_ptr(arg: number): number {
8396 if(!isWasmInitialized) {
8397 throw new Error("initializeWasm() must be awaited first!");
8399 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_clone_ptr(arg);
8400 return nativeResponseValue;
8402 // struct LDKCResult_ScoringParametersDecodeErrorZ CResult_ScoringParametersDecodeErrorZ_clone(const struct LDKCResult_ScoringParametersDecodeErrorZ *NONNULL_PTR orig);
8404 export function CResult_ScoringParametersDecodeErrorZ_clone(orig: number): number {
8405 if(!isWasmInitialized) {
8406 throw new Error("initializeWasm() must be awaited first!");
8408 const nativeResponseValue = wasm.TS_CResult_ScoringParametersDecodeErrorZ_clone(orig);
8409 return nativeResponseValue;
8411 // struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_ok(struct LDKScorer o);
8413 export function CResult_ScorerDecodeErrorZ_ok(o: number): number {
8414 if(!isWasmInitialized) {
8415 throw new Error("initializeWasm() must be awaited first!");
8417 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_ok(o);
8418 return nativeResponseValue;
8420 // struct LDKCResult_ScorerDecodeErrorZ CResult_ScorerDecodeErrorZ_err(struct LDKDecodeError e);
8422 export function CResult_ScorerDecodeErrorZ_err(e: number): number {
8423 if(!isWasmInitialized) {
8424 throw new Error("initializeWasm() must be awaited first!");
8426 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_err(e);
8427 return nativeResponseValue;
8429 // bool CResult_ScorerDecodeErrorZ_is_ok(const struct LDKCResult_ScorerDecodeErrorZ *NONNULL_PTR o);
8431 export function CResult_ScorerDecodeErrorZ_is_ok(o: number): boolean {
8432 if(!isWasmInitialized) {
8433 throw new Error("initializeWasm() must be awaited first!");
8435 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_is_ok(o);
8436 return nativeResponseValue;
8438 // void CResult_ScorerDecodeErrorZ_free(struct LDKCResult_ScorerDecodeErrorZ _res);
8440 export function CResult_ScorerDecodeErrorZ_free(_res: number): void {
8441 if(!isWasmInitialized) {
8442 throw new Error("initializeWasm() must be awaited first!");
8444 const nativeResponseValue = wasm.TS_CResult_ScorerDecodeErrorZ_free(_res);
8445 // debug statements here
8447 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
8449 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
8450 if(!isWasmInitialized) {
8451 throw new Error("initializeWasm() must be awaited first!");
8453 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
8454 return nativeResponseValue;
8456 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
8458 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
8459 if(!isWasmInitialized) {
8460 throw new Error("initializeWasm() must be awaited first!");
8462 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
8463 return nativeResponseValue;
8465 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
8467 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
8468 if(!isWasmInitialized) {
8469 throw new Error("initializeWasm() must be awaited first!");
8471 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
8472 return nativeResponseValue;
8474 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
8476 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
8477 if(!isWasmInitialized) {
8478 throw new Error("initializeWasm() must be awaited first!");
8480 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
8481 // debug statements here
8483 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8485 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8486 if(!isWasmInitialized) {
8487 throw new Error("initializeWasm() must be awaited first!");
8489 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8490 return nativeResponseValue;
8492 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8494 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8495 if(!isWasmInitialized) {
8496 throw new Error("initializeWasm() must be awaited first!");
8498 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8499 return nativeResponseValue;
8501 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8503 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8504 if(!isWasmInitialized) {
8505 throw new Error("initializeWasm() must be awaited first!");
8507 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8508 return nativeResponseValue;
8510 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8512 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8513 if(!isWasmInitialized) {
8514 throw new Error("initializeWasm() must be awaited first!");
8516 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8517 // debug statements here
8519 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8521 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8522 if(!isWasmInitialized) {
8523 throw new Error("initializeWasm() must be awaited first!");
8525 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8526 return nativeResponseValue;
8528 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8530 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8531 if(!isWasmInitialized) {
8532 throw new Error("initializeWasm() must be awaited first!");
8534 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8535 return nativeResponseValue;
8537 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8539 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8540 if(!isWasmInitialized) {
8541 throw new Error("initializeWasm() must be awaited first!");
8543 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8544 return nativeResponseValue;
8546 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8548 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8549 if(!isWasmInitialized) {
8550 throw new Error("initializeWasm() must be awaited first!");
8552 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8553 // debug statements here
8555 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8557 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8558 if(!isWasmInitialized) {
8559 throw new Error("initializeWasm() must be awaited first!");
8561 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8562 return nativeResponseValue;
8564 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8566 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8567 if(!isWasmInitialized) {
8568 throw new Error("initializeWasm() must be awaited first!");
8570 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8571 return nativeResponseValue;
8573 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8575 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8576 if(!isWasmInitialized) {
8577 throw new Error("initializeWasm() must be awaited first!");
8579 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8580 return nativeResponseValue;
8582 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8584 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8585 if(!isWasmInitialized) {
8586 throw new Error("initializeWasm() must be awaited first!");
8588 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8589 // debug statements here
8591 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8593 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8594 if(!isWasmInitialized) {
8595 throw new Error("initializeWasm() must be awaited first!");
8597 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8598 return nativeResponseValue;
8600 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8602 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8603 if(!isWasmInitialized) {
8604 throw new Error("initializeWasm() must be awaited first!");
8606 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8607 return nativeResponseValue;
8609 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8611 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8612 if(!isWasmInitialized) {
8613 throw new Error("initializeWasm() must be awaited first!");
8615 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8616 return nativeResponseValue;
8618 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8620 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8621 if(!isWasmInitialized) {
8622 throw new Error("initializeWasm() must be awaited first!");
8624 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8625 // debug statements here
8627 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8629 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8630 if(!isWasmInitialized) {
8631 throw new Error("initializeWasm() must be awaited first!");
8633 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
8634 return nativeResponseValue;
8636 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8638 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
8639 if(!isWasmInitialized) {
8640 throw new Error("initializeWasm() must be awaited first!");
8642 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
8643 return nativeResponseValue;
8645 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
8647 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8648 if(!isWasmInitialized) {
8649 throw new Error("initializeWasm() must be awaited first!");
8651 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
8652 return nativeResponseValue;
8654 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
8656 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
8657 if(!isWasmInitialized) {
8658 throw new Error("initializeWasm() must be awaited first!");
8660 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
8661 // debug statements here
8663 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
8665 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
8666 if(!isWasmInitialized) {
8667 throw new Error("initializeWasm() must be awaited first!");
8669 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
8670 return nativeResponseValue;
8672 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8674 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
8675 if(!isWasmInitialized) {
8676 throw new Error("initializeWasm() must be awaited first!");
8678 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
8679 return nativeResponseValue;
8681 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8683 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8684 if(!isWasmInitialized) {
8685 throw new Error("initializeWasm() must be awaited first!");
8687 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
8688 return nativeResponseValue;
8690 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
8692 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
8693 if(!isWasmInitialized) {
8694 throw new Error("initializeWasm() must be awaited first!");
8696 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
8697 // debug statements here
8699 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8701 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8702 if(!isWasmInitialized) {
8703 throw new Error("initializeWasm() must be awaited first!");
8705 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8706 return nativeResponseValue;
8708 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8710 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8711 if(!isWasmInitialized) {
8712 throw new Error("initializeWasm() must be awaited first!");
8714 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
8715 return nativeResponseValue;
8717 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
8719 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
8720 if(!isWasmInitialized) {
8721 throw new Error("initializeWasm() must be awaited first!");
8723 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
8724 return nativeResponseValue;
8726 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8728 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
8729 if(!isWasmInitialized) {
8730 throw new Error("initializeWasm() must be awaited first!");
8732 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
8733 return nativeResponseValue;
8735 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8737 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8738 if(!isWasmInitialized) {
8739 throw new Error("initializeWasm() must be awaited first!");
8741 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
8742 return nativeResponseValue;
8744 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
8746 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
8747 if(!isWasmInitialized) {
8748 throw new Error("initializeWasm() must be awaited first!");
8750 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
8751 // debug statements here
8753 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8755 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8756 if(!isWasmInitialized) {
8757 throw new Error("initializeWasm() must be awaited first!");
8759 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8760 return nativeResponseValue;
8762 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8764 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8765 if(!isWasmInitialized) {
8766 throw new Error("initializeWasm() must be awaited first!");
8768 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
8769 return nativeResponseValue;
8771 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
8773 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
8774 if(!isWasmInitialized) {
8775 throw new Error("initializeWasm() must be awaited first!");
8777 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
8778 return nativeResponseValue;
8780 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
8782 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
8783 if(!isWasmInitialized) {
8784 throw new Error("initializeWasm() must be awaited first!");
8786 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
8787 return nativeResponseValue;
8789 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
8791 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
8792 if(!isWasmInitialized) {
8793 throw new Error("initializeWasm() must be awaited first!");
8795 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
8796 return nativeResponseValue;
8798 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
8800 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
8801 if(!isWasmInitialized) {
8802 throw new Error("initializeWasm() must be awaited first!");
8804 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
8805 // debug statements here
8807 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
8809 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
8810 if(!isWasmInitialized) {
8811 throw new Error("initializeWasm() must be awaited first!");
8813 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
8814 return nativeResponseValue;
8816 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
8818 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
8819 if(!isWasmInitialized) {
8820 throw new Error("initializeWasm() must be awaited first!");
8822 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
8823 return nativeResponseValue;
8825 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
8827 export function CVec_PaymentPreimageZ_free(_res: number): void {
8828 if(!isWasmInitialized) {
8829 throw new Error("initializeWasm() must be awaited first!");
8831 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
8832 // debug statements here
8834 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
8836 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
8837 if(!isWasmInitialized) {
8838 throw new Error("initializeWasm() must be awaited first!");
8840 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
8841 return nativeResponseValue;
8843 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
8845 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
8846 if(!isWasmInitialized) {
8847 throw new Error("initializeWasm() must be awaited first!");
8849 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
8850 return nativeResponseValue;
8852 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
8854 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
8855 if(!isWasmInitialized) {
8856 throw new Error("initializeWasm() must be awaited first!");
8858 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
8859 return nativeResponseValue;
8861 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
8863 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
8864 if(!isWasmInitialized) {
8865 throw new Error("initializeWasm() must be awaited first!");
8867 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
8868 // debug statements here
8870 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
8872 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
8873 if(!isWasmInitialized) {
8874 throw new Error("initializeWasm() must be awaited first!");
8876 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
8877 return nativeResponseValue;
8879 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
8881 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
8882 if(!isWasmInitialized) {
8883 throw new Error("initializeWasm() must be awaited first!");
8885 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
8886 return nativeResponseValue;
8888 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
8890 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
8891 if(!isWasmInitialized) {
8892 throw new Error("initializeWasm() must be awaited first!");
8894 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
8895 return nativeResponseValue;
8897 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
8899 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
8900 if(!isWasmInitialized) {
8901 throw new Error("initializeWasm() must be awaited first!");
8903 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
8904 // debug statements here
8906 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
8908 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
8909 if(!isWasmInitialized) {
8910 throw new Error("initializeWasm() must be awaited first!");
8912 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
8913 return nativeResponseValue;
8915 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
8917 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
8918 if(!isWasmInitialized) {
8919 throw new Error("initializeWasm() must be awaited first!");
8921 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
8922 return nativeResponseValue;
8924 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
8926 export function CResult_SignatureNoneZ_ok(o: number): number {
8927 if(!isWasmInitialized) {
8928 throw new Error("initializeWasm() must be awaited first!");
8930 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
8931 return nativeResponseValue;
8933 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
8935 export function CResult_SignatureNoneZ_err(): number {
8936 if(!isWasmInitialized) {
8937 throw new Error("initializeWasm() must be awaited first!");
8939 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
8940 return nativeResponseValue;
8942 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
8944 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
8945 if(!isWasmInitialized) {
8946 throw new Error("initializeWasm() must be awaited first!");
8948 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
8949 return nativeResponseValue;
8951 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
8953 export function CResult_SignatureNoneZ_free(_res: number): void {
8954 if(!isWasmInitialized) {
8955 throw new Error("initializeWasm() must be awaited first!");
8957 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
8958 // debug statements here
8960 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
8962 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
8963 if(!isWasmInitialized) {
8964 throw new Error("initializeWasm() must be awaited first!");
8966 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
8967 return nativeResponseValue;
8969 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
8971 export function CResult_SignatureNoneZ_clone(orig: number): number {
8972 if(!isWasmInitialized) {
8973 throw new Error("initializeWasm() must be awaited first!");
8975 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
8976 return nativeResponseValue;
8978 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
8980 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
8981 if(!isWasmInitialized) {
8982 throw new Error("initializeWasm() must be awaited first!");
8984 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
8985 return nativeResponseValue;
8987 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
8989 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
8990 if(!isWasmInitialized) {
8991 throw new Error("initializeWasm() must be awaited first!");
8993 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
8994 return nativeResponseValue;
8996 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
8998 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
8999 if(!isWasmInitialized) {
9000 throw new Error("initializeWasm() must be awaited first!");
9002 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
9003 return nativeResponseValue;
9005 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
9007 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
9008 if(!isWasmInitialized) {
9009 throw new Error("initializeWasm() must be awaited first!");
9011 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
9012 // debug statements here
9014 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
9016 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
9017 if(!isWasmInitialized) {
9018 throw new Error("initializeWasm() must be awaited first!");
9020 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
9021 return nativeResponseValue;
9023 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
9025 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
9026 if(!isWasmInitialized) {
9027 throw new Error("initializeWasm() must be awaited first!");
9029 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
9030 return nativeResponseValue;
9032 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
9034 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
9035 if(!isWasmInitialized) {
9036 throw new Error("initializeWasm() must be awaited first!");
9038 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
9039 return nativeResponseValue;
9041 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
9043 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
9044 if(!isWasmInitialized) {
9045 throw new Error("initializeWasm() must be awaited first!");
9047 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
9048 // debug statements here
9050 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
9052 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
9053 if(!isWasmInitialized) {
9054 throw new Error("initializeWasm() must be awaited first!");
9056 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
9057 return nativeResponseValue;
9059 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
9061 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
9062 if(!isWasmInitialized) {
9063 throw new Error("initializeWasm() must be awaited first!");
9065 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
9066 return nativeResponseValue;
9068 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
9070 export function CResult_SecretKeyNoneZ_ok(o: number): number {
9071 if(!isWasmInitialized) {
9072 throw new Error("initializeWasm() must be awaited first!");
9074 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
9075 return nativeResponseValue;
9077 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
9079 export function CResult_SecretKeyNoneZ_err(): number {
9080 if(!isWasmInitialized) {
9081 throw new Error("initializeWasm() must be awaited first!");
9083 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
9084 return nativeResponseValue;
9086 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
9088 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
9089 if(!isWasmInitialized) {
9090 throw new Error("initializeWasm() must be awaited first!");
9092 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
9093 return nativeResponseValue;
9095 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
9097 export function CResult_SecretKeyNoneZ_free(_res: number): void {
9098 if(!isWasmInitialized) {
9099 throw new Error("initializeWasm() must be awaited first!");
9101 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
9102 // debug statements here
9104 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
9106 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
9107 if(!isWasmInitialized) {
9108 throw new Error("initializeWasm() must be awaited first!");
9110 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
9111 return nativeResponseValue;
9113 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
9115 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
9116 if(!isWasmInitialized) {
9117 throw new Error("initializeWasm() must be awaited first!");
9119 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
9120 return nativeResponseValue;
9122 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
9124 export function CResult_SignDecodeErrorZ_ok(o: number): number {
9125 if(!isWasmInitialized) {
9126 throw new Error("initializeWasm() must be awaited first!");
9128 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
9129 return nativeResponseValue;
9131 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
9133 export function CResult_SignDecodeErrorZ_err(e: number): number {
9134 if(!isWasmInitialized) {
9135 throw new Error("initializeWasm() must be awaited first!");
9137 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
9138 return nativeResponseValue;
9140 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
9142 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
9143 if(!isWasmInitialized) {
9144 throw new Error("initializeWasm() must be awaited first!");
9146 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
9147 return nativeResponseValue;
9149 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
9151 export function CResult_SignDecodeErrorZ_free(_res: number): void {
9152 if(!isWasmInitialized) {
9153 throw new Error("initializeWasm() must be awaited first!");
9155 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
9156 // debug statements here
9158 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
9160 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
9161 if(!isWasmInitialized) {
9162 throw new Error("initializeWasm() must be awaited first!");
9164 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
9165 return nativeResponseValue;
9167 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
9169 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
9170 if(!isWasmInitialized) {
9171 throw new Error("initializeWasm() must be awaited first!");
9173 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
9174 return nativeResponseValue;
9176 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
9178 export function CVec_u5Z_free(_res: number): void {
9179 if(!isWasmInitialized) {
9180 throw new Error("initializeWasm() must be awaited first!");
9182 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
9183 // debug statements here
9185 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
9187 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
9188 if(!isWasmInitialized) {
9189 throw new Error("initializeWasm() must be awaited first!");
9191 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
9192 return nativeResponseValue;
9194 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
9196 export function CResult_RecoverableSignatureNoneZ_err(): number {
9197 if(!isWasmInitialized) {
9198 throw new Error("initializeWasm() must be awaited first!");
9200 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
9201 return nativeResponseValue;
9203 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
9205 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
9206 if(!isWasmInitialized) {
9207 throw new Error("initializeWasm() must be awaited first!");
9209 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
9210 return nativeResponseValue;
9212 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
9214 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
9215 if(!isWasmInitialized) {
9216 throw new Error("initializeWasm() must be awaited first!");
9218 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
9219 // debug statements here
9221 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
9223 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
9224 if(!isWasmInitialized) {
9225 throw new Error("initializeWasm() must be awaited first!");
9227 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
9228 return nativeResponseValue;
9230 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
9232 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
9233 if(!isWasmInitialized) {
9234 throw new Error("initializeWasm() must be awaited first!");
9236 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
9237 return nativeResponseValue;
9239 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
9241 export function CVec_u8Z_free(_res: number): void {
9242 if(!isWasmInitialized) {
9243 throw new Error("initializeWasm() must be awaited first!");
9245 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
9246 // debug statements here
9248 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
9250 export function CVec_CVec_u8ZZ_free(_res: number): void {
9251 if(!isWasmInitialized) {
9252 throw new Error("initializeWasm() must be awaited first!");
9254 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
9255 // debug statements here
9257 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
9259 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
9260 if(!isWasmInitialized) {
9261 throw new Error("initializeWasm() must be awaited first!");
9263 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
9264 return nativeResponseValue;
9266 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
9268 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
9269 if(!isWasmInitialized) {
9270 throw new Error("initializeWasm() must be awaited first!");
9272 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
9273 return nativeResponseValue;
9275 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
9277 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
9278 if(!isWasmInitialized) {
9279 throw new Error("initializeWasm() must be awaited first!");
9281 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
9282 return nativeResponseValue;
9284 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
9286 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
9287 if(!isWasmInitialized) {
9288 throw new Error("initializeWasm() must be awaited first!");
9290 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
9291 // debug statements here
9293 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
9295 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
9296 if(!isWasmInitialized) {
9297 throw new Error("initializeWasm() must be awaited first!");
9299 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
9300 return nativeResponseValue;
9302 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
9304 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
9305 if(!isWasmInitialized) {
9306 throw new Error("initializeWasm() must be awaited first!");
9308 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
9309 return nativeResponseValue;
9311 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
9313 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
9314 if(!isWasmInitialized) {
9315 throw new Error("initializeWasm() must be awaited first!");
9317 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
9318 return nativeResponseValue;
9320 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
9322 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
9323 if(!isWasmInitialized) {
9324 throw new Error("initializeWasm() must be awaited first!");
9326 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
9327 return nativeResponseValue;
9329 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
9331 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
9332 if(!isWasmInitialized) {
9333 throw new Error("initializeWasm() must be awaited first!");
9335 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
9336 return nativeResponseValue;
9338 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
9340 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
9341 if(!isWasmInitialized) {
9342 throw new Error("initializeWasm() must be awaited first!");
9344 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
9345 // debug statements here
9347 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
9349 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
9350 if(!isWasmInitialized) {
9351 throw new Error("initializeWasm() must be awaited first!");
9353 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
9354 return nativeResponseValue;
9356 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
9358 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
9359 if(!isWasmInitialized) {
9360 throw new Error("initializeWasm() must be awaited first!");
9362 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
9363 return nativeResponseValue;
9365 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
9367 export function CVec_TxOutZ_free(_res: number): void {
9368 if(!isWasmInitialized) {
9369 throw new Error("initializeWasm() must be awaited first!");
9371 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
9372 // debug statements here
9374 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
9376 export function CResult_TransactionNoneZ_ok(o: number): number {
9377 if(!isWasmInitialized) {
9378 throw new Error("initializeWasm() must be awaited first!");
9380 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
9381 return nativeResponseValue;
9383 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
9385 export function CResult_TransactionNoneZ_err(): number {
9386 if(!isWasmInitialized) {
9387 throw new Error("initializeWasm() must be awaited first!");
9389 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
9390 return nativeResponseValue;
9392 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
9394 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
9395 if(!isWasmInitialized) {
9396 throw new Error("initializeWasm() must be awaited first!");
9398 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
9399 return nativeResponseValue;
9401 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
9403 export function CResult_TransactionNoneZ_free(_res: number): void {
9404 if(!isWasmInitialized) {
9405 throw new Error("initializeWasm() must be awaited first!");
9407 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
9408 // debug statements here
9410 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
9412 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
9413 if(!isWasmInitialized) {
9414 throw new Error("initializeWasm() must be awaited first!");
9416 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
9417 return nativeResponseValue;
9419 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
9421 export function CResult_TransactionNoneZ_clone(orig: number): number {
9422 if(!isWasmInitialized) {
9423 throw new Error("initializeWasm() must be awaited first!");
9425 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
9426 return nativeResponseValue;
9428 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
9430 export function COption_u16Z_some(o: number): number {
9431 if(!isWasmInitialized) {
9432 throw new Error("initializeWasm() must be awaited first!");
9434 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
9435 return nativeResponseValue;
9437 // struct LDKCOption_u16Z COption_u16Z_none(void);
9439 export function COption_u16Z_none(): number {
9440 if(!isWasmInitialized) {
9441 throw new Error("initializeWasm() must be awaited first!");
9443 const nativeResponseValue = wasm.TS_COption_u16Z_none();
9444 return nativeResponseValue;
9446 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
9448 export function COption_u16Z_free(_res: number): void {
9449 if(!isWasmInitialized) {
9450 throw new Error("initializeWasm() must be awaited first!");
9452 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
9453 // debug statements here
9455 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
9457 export function COption_u16Z_clone_ptr(arg: number): number {
9458 if(!isWasmInitialized) {
9459 throw new Error("initializeWasm() must be awaited first!");
9461 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
9462 return nativeResponseValue;
9464 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
9466 export function COption_u16Z_clone(orig: number): number {
9467 if(!isWasmInitialized) {
9468 throw new Error("initializeWasm() must be awaited first!");
9470 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
9471 return nativeResponseValue;
9473 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
9475 export function CResult_NoneAPIErrorZ_ok(): number {
9476 if(!isWasmInitialized) {
9477 throw new Error("initializeWasm() must be awaited first!");
9479 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
9480 return nativeResponseValue;
9482 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
9484 export function CResult_NoneAPIErrorZ_err(e: number): number {
9485 if(!isWasmInitialized) {
9486 throw new Error("initializeWasm() must be awaited first!");
9488 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
9489 return nativeResponseValue;
9491 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
9493 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
9494 if(!isWasmInitialized) {
9495 throw new Error("initializeWasm() must be awaited first!");
9497 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
9498 return nativeResponseValue;
9500 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
9502 export function CResult_NoneAPIErrorZ_free(_res: number): void {
9503 if(!isWasmInitialized) {
9504 throw new Error("initializeWasm() must be awaited first!");
9506 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
9507 // debug statements here
9509 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
9511 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
9512 if(!isWasmInitialized) {
9513 throw new Error("initializeWasm() must be awaited first!");
9515 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
9516 return nativeResponseValue;
9518 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
9520 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
9521 if(!isWasmInitialized) {
9522 throw new Error("initializeWasm() must be awaited first!");
9524 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
9525 return nativeResponseValue;
9527 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
9529 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
9534 // debug statements here
9536 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
9538 export function CVec_APIErrorZ_free(_res: number): void {
9539 if(!isWasmInitialized) {
9540 throw new Error("initializeWasm() must be awaited first!");
9542 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
9543 // debug statements here
9545 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
9547 export function CResult__u832APIErrorZ_ok(o: number): number {
9548 if(!isWasmInitialized) {
9549 throw new Error("initializeWasm() must be awaited first!");
9551 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
9552 return nativeResponseValue;
9554 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
9556 export function CResult__u832APIErrorZ_err(e: number): number {
9557 if(!isWasmInitialized) {
9558 throw new Error("initializeWasm() must be awaited first!");
9560 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
9561 return nativeResponseValue;
9563 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
9565 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
9566 if(!isWasmInitialized) {
9567 throw new Error("initializeWasm() must be awaited first!");
9569 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
9570 return nativeResponseValue;
9572 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
9574 export function CResult__u832APIErrorZ_free(_res: number): void {
9575 if(!isWasmInitialized) {
9576 throw new Error("initializeWasm() must be awaited first!");
9578 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
9579 // debug statements here
9581 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
9583 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
9584 if(!isWasmInitialized) {
9585 throw new Error("initializeWasm() must be awaited first!");
9587 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
9588 return nativeResponseValue;
9590 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
9592 export function CResult__u832APIErrorZ_clone(orig: number): number {
9593 if(!isWasmInitialized) {
9594 throw new Error("initializeWasm() must be awaited first!");
9596 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
9597 return nativeResponseValue;
9599 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
9601 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
9602 if(!isWasmInitialized) {
9603 throw new Error("initializeWasm() must be awaited first!");
9605 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
9606 return nativeResponseValue;
9608 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9610 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
9611 if(!isWasmInitialized) {
9612 throw new Error("initializeWasm() must be awaited first!");
9614 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
9615 return nativeResponseValue;
9617 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
9619 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
9620 if(!isWasmInitialized) {
9621 throw new Error("initializeWasm() must be awaited first!");
9623 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
9624 return nativeResponseValue;
9626 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
9628 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
9629 if(!isWasmInitialized) {
9630 throw new Error("initializeWasm() must be awaited first!");
9632 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
9633 // debug statements here
9635 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
9637 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
9638 if(!isWasmInitialized) {
9639 throw new Error("initializeWasm() must be awaited first!");
9641 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
9642 return nativeResponseValue;
9644 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
9646 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
9647 if(!isWasmInitialized) {
9648 throw new Error("initializeWasm() must be awaited first!");
9650 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
9651 return nativeResponseValue;
9653 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
9655 export function CResult_NonePaymentSendFailureZ_ok(): number {
9656 if(!isWasmInitialized) {
9657 throw new Error("initializeWasm() must be awaited first!");
9659 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
9660 return nativeResponseValue;
9662 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9664 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
9665 if(!isWasmInitialized) {
9666 throw new Error("initializeWasm() must be awaited first!");
9668 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
9669 return nativeResponseValue;
9671 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
9673 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
9674 if(!isWasmInitialized) {
9675 throw new Error("initializeWasm() must be awaited first!");
9677 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
9678 return nativeResponseValue;
9680 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
9682 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
9683 if(!isWasmInitialized) {
9684 throw new Error("initializeWasm() must be awaited first!");
9686 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
9687 // debug statements here
9689 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
9691 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
9692 if(!isWasmInitialized) {
9693 throw new Error("initializeWasm() must be awaited first!");
9695 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
9696 return nativeResponseValue;
9698 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
9700 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
9701 if(!isWasmInitialized) {
9702 throw new Error("initializeWasm() must be awaited first!");
9704 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
9705 return nativeResponseValue;
9707 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
9709 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
9710 if(!isWasmInitialized) {
9711 throw new Error("initializeWasm() must be awaited first!");
9713 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
9714 return nativeResponseValue;
9716 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
9718 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
9719 if(!isWasmInitialized) {
9720 throw new Error("initializeWasm() must be awaited first!");
9722 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
9723 return nativeResponseValue;
9725 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
9727 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
9728 if(!isWasmInitialized) {
9729 throw new Error("initializeWasm() must be awaited first!");
9731 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
9732 return nativeResponseValue;
9734 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
9736 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
9737 if(!isWasmInitialized) {
9738 throw new Error("initializeWasm() must be awaited first!");
9740 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
9741 // debug statements here
9743 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
9745 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
9746 if(!isWasmInitialized) {
9747 throw new Error("initializeWasm() must be awaited first!");
9749 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
9750 return nativeResponseValue;
9752 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
9754 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
9755 if(!isWasmInitialized) {
9756 throw new Error("initializeWasm() must be awaited first!");
9758 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
9759 return nativeResponseValue;
9761 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
9763 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
9764 if(!isWasmInitialized) {
9765 throw new Error("initializeWasm() must be awaited first!");
9767 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
9768 return nativeResponseValue;
9770 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
9772 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
9773 if(!isWasmInitialized) {
9774 throw new Error("initializeWasm() must be awaited first!");
9776 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
9777 // debug statements here
9779 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
9781 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
9782 if(!isWasmInitialized) {
9783 throw new Error("initializeWasm() must be awaited first!");
9785 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
9786 return nativeResponseValue;
9788 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
9790 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
9791 if(!isWasmInitialized) {
9792 throw new Error("initializeWasm() must be awaited first!");
9794 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
9795 return nativeResponseValue;
9797 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9799 export function CVec_NetAddressZ_free(_res: number): void {
9800 if(!isWasmInitialized) {
9801 throw new Error("initializeWasm() must be awaited first!");
9803 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9804 // debug statements here
9806 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
9808 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
9809 if(!isWasmInitialized) {
9810 throw new Error("initializeWasm() must be awaited first!");
9812 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
9813 return nativeResponseValue;
9815 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
9817 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
9818 if(!isWasmInitialized) {
9819 throw new Error("initializeWasm() must be awaited first!");
9821 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
9822 return nativeResponseValue;
9824 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
9826 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
9827 if(!isWasmInitialized) {
9828 throw new Error("initializeWasm() must be awaited first!");
9830 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
9831 return nativeResponseValue;
9833 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
9835 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
9836 if(!isWasmInitialized) {
9837 throw new Error("initializeWasm() must be awaited first!");
9839 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
9840 // debug statements here
9842 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
9844 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
9845 if(!isWasmInitialized) {
9846 throw new Error("initializeWasm() must be awaited first!");
9848 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
9849 return nativeResponseValue;
9851 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
9853 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
9854 if(!isWasmInitialized) {
9855 throw new Error("initializeWasm() must be awaited first!");
9857 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
9858 return nativeResponseValue;
9860 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
9862 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
9863 if(!isWasmInitialized) {
9864 throw new Error("initializeWasm() must be awaited first!");
9866 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
9867 return nativeResponseValue;
9869 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
9871 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
9872 if(!isWasmInitialized) {
9873 throw new Error("initializeWasm() must be awaited first!");
9875 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
9876 // debug statements here
9878 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
9880 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
9881 if(!isWasmInitialized) {
9882 throw new Error("initializeWasm() must be awaited first!");
9884 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
9885 return nativeResponseValue;
9887 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
9889 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
9890 if(!isWasmInitialized) {
9891 throw new Error("initializeWasm() must be awaited first!");
9893 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
9894 return nativeResponseValue;
9896 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
9898 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
9899 if(!isWasmInitialized) {
9900 throw new Error("initializeWasm() must be awaited first!");
9902 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
9903 return nativeResponseValue;
9905 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
9907 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
9908 if(!isWasmInitialized) {
9909 throw new Error("initializeWasm() must be awaited first!");
9911 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
9912 return nativeResponseValue;
9914 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
9916 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
9917 if(!isWasmInitialized) {
9918 throw new Error("initializeWasm() must be awaited first!");
9920 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
9921 return nativeResponseValue;
9923 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
9925 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
9926 if(!isWasmInitialized) {
9927 throw new Error("initializeWasm() must be awaited first!");
9929 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
9930 // debug statements here
9932 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
9934 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
9935 if(!isWasmInitialized) {
9936 throw new Error("initializeWasm() must be awaited first!");
9938 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
9939 return nativeResponseValue;
9941 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
9943 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
9944 if(!isWasmInitialized) {
9945 throw new Error("initializeWasm() must be awaited first!");
9947 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
9948 return nativeResponseValue;
9950 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
9952 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
9953 if(!isWasmInitialized) {
9954 throw new Error("initializeWasm() must be awaited first!");
9956 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
9957 return nativeResponseValue;
9959 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
9961 export function CResult_PaymentSecretNoneZ_err(): number {
9962 if(!isWasmInitialized) {
9963 throw new Error("initializeWasm() must be awaited first!");
9965 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
9966 return nativeResponseValue;
9968 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
9970 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
9971 if(!isWasmInitialized) {
9972 throw new Error("initializeWasm() must be awaited first!");
9974 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
9975 return nativeResponseValue;
9977 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
9979 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
9980 if(!isWasmInitialized) {
9981 throw new Error("initializeWasm() must be awaited first!");
9983 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
9984 // debug statements here
9986 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
9988 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
9989 if(!isWasmInitialized) {
9990 throw new Error("initializeWasm() must be awaited first!");
9992 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
9993 return nativeResponseValue;
9995 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
9997 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
9998 if(!isWasmInitialized) {
9999 throw new Error("initializeWasm() must be awaited first!");
10001 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
10002 return nativeResponseValue;
10004 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
10006 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
10007 if(!isWasmInitialized) {
10008 throw new Error("initializeWasm() must be awaited first!");
10010 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
10011 return nativeResponseValue;
10013 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
10015 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
10016 if(!isWasmInitialized) {
10017 throw new Error("initializeWasm() must be awaited first!");
10019 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
10020 return nativeResponseValue;
10022 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
10024 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
10025 if(!isWasmInitialized) {
10026 throw new Error("initializeWasm() must be awaited first!");
10028 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
10029 return nativeResponseValue;
10031 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
10033 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
10034 if(!isWasmInitialized) {
10035 throw new Error("initializeWasm() must be awaited first!");
10037 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
10038 // debug statements here
10040 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
10042 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
10043 if(!isWasmInitialized) {
10044 throw new Error("initializeWasm() must be awaited first!");
10046 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
10047 return nativeResponseValue;
10049 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
10051 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
10052 if(!isWasmInitialized) {
10053 throw new Error("initializeWasm() must be awaited first!");
10055 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
10056 return nativeResponseValue;
10058 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
10060 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
10061 if(!isWasmInitialized) {
10062 throw new Error("initializeWasm() must be awaited first!");
10064 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
10065 return nativeResponseValue;
10067 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
10069 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
10070 if(!isWasmInitialized) {
10071 throw new Error("initializeWasm() must be awaited first!");
10073 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
10074 return nativeResponseValue;
10076 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
10078 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
10079 if(!isWasmInitialized) {
10080 throw new Error("initializeWasm() must be awaited first!");
10082 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
10083 return nativeResponseValue;
10085 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
10087 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
10088 if(!isWasmInitialized) {
10089 throw new Error("initializeWasm() must be awaited first!");
10091 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
10092 // debug statements here
10094 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
10096 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
10097 if(!isWasmInitialized) {
10098 throw new Error("initializeWasm() must be awaited first!");
10100 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
10101 return nativeResponseValue;
10103 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
10105 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
10106 if(!isWasmInitialized) {
10107 throw new Error("initializeWasm() must be awaited first!");
10109 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
10110 return nativeResponseValue;
10112 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
10114 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
10115 if(!isWasmInitialized) {
10116 throw new Error("initializeWasm() must be awaited first!");
10118 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
10119 return nativeResponseValue;
10121 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
10123 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
10124 if(!isWasmInitialized) {
10125 throw new Error("initializeWasm() must be awaited first!");
10127 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
10128 return nativeResponseValue;
10130 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
10132 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
10133 if(!isWasmInitialized) {
10134 throw new Error("initializeWasm() must be awaited first!");
10136 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
10137 return nativeResponseValue;
10139 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
10141 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
10142 if(!isWasmInitialized) {
10143 throw new Error("initializeWasm() must be awaited first!");
10145 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
10146 // debug statements here
10148 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
10150 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
10151 if(!isWasmInitialized) {
10152 throw new Error("initializeWasm() must be awaited first!");
10154 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
10155 return nativeResponseValue;
10157 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
10159 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
10160 if(!isWasmInitialized) {
10161 throw new Error("initializeWasm() must be awaited first!");
10163 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
10164 return nativeResponseValue;
10166 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
10168 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
10169 if(!isWasmInitialized) {
10170 throw new Error("initializeWasm() must be awaited first!");
10172 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
10173 return nativeResponseValue;
10175 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
10177 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
10178 if(!isWasmInitialized) {
10179 throw new Error("initializeWasm() must be awaited first!");
10181 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
10182 return nativeResponseValue;
10184 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
10186 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
10187 if(!isWasmInitialized) {
10188 throw new Error("initializeWasm() must be awaited first!");
10190 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
10191 return nativeResponseValue;
10193 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
10195 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
10196 if(!isWasmInitialized) {
10197 throw new Error("initializeWasm() must be awaited first!");
10199 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
10200 // debug statements here
10202 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
10204 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
10205 if(!isWasmInitialized) {
10206 throw new Error("initializeWasm() must be awaited first!");
10208 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
10209 return nativeResponseValue;
10211 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
10213 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
10214 if(!isWasmInitialized) {
10215 throw new Error("initializeWasm() must be awaited first!");
10217 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
10218 return nativeResponseValue;
10220 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
10222 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
10223 if(!isWasmInitialized) {
10224 throw new Error("initializeWasm() must be awaited first!");
10226 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
10227 return nativeResponseValue;
10229 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
10231 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
10232 if(!isWasmInitialized) {
10233 throw new Error("initializeWasm() must be awaited first!");
10235 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
10236 return nativeResponseValue;
10238 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
10240 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
10241 if(!isWasmInitialized) {
10242 throw new Error("initializeWasm() must be awaited first!");
10244 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
10245 return nativeResponseValue;
10247 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
10249 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
10250 if(!isWasmInitialized) {
10251 throw new Error("initializeWasm() must be awaited first!");
10253 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
10254 // debug statements here
10256 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
10258 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
10259 if(!isWasmInitialized) {
10260 throw new Error("initializeWasm() must be awaited first!");
10262 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
10263 return nativeResponseValue;
10265 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
10267 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
10268 if(!isWasmInitialized) {
10269 throw new Error("initializeWasm() must be awaited first!");
10271 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
10272 return nativeResponseValue;
10274 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
10276 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
10277 if(!isWasmInitialized) {
10278 throw new Error("initializeWasm() must be awaited first!");
10280 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
10281 return nativeResponseValue;
10283 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
10285 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
10286 if(!isWasmInitialized) {
10287 throw new Error("initializeWasm() must be awaited first!");
10289 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
10290 return nativeResponseValue;
10292 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
10294 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
10295 if(!isWasmInitialized) {
10296 throw new Error("initializeWasm() must be awaited first!");
10298 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
10299 return nativeResponseValue;
10301 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
10303 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
10304 if(!isWasmInitialized) {
10305 throw new Error("initializeWasm() must be awaited first!");
10307 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
10308 // debug statements here
10310 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
10312 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
10313 if(!isWasmInitialized) {
10314 throw new Error("initializeWasm() must be awaited first!");
10316 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
10317 return nativeResponseValue;
10319 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
10321 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
10322 if(!isWasmInitialized) {
10323 throw new Error("initializeWasm() must be awaited first!");
10325 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
10326 return nativeResponseValue;
10328 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
10330 export function CVec_ChannelMonitorZ_free(_res: number): void {
10331 if(!isWasmInitialized) {
10332 throw new Error("initializeWasm() must be awaited first!");
10334 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
10335 // debug statements here
10337 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
10339 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
10340 if(!isWasmInitialized) {
10341 throw new Error("initializeWasm() must be awaited first!");
10343 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
10344 return nativeResponseValue;
10346 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
10348 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
10349 if(!isWasmInitialized) {
10350 throw new Error("initializeWasm() must be awaited first!");
10352 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
10353 // debug statements here
10355 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
10357 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
10358 if(!isWasmInitialized) {
10359 throw new Error("initializeWasm() must be awaited first!");
10361 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
10362 return nativeResponseValue;
10364 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
10366 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
10367 if(!isWasmInitialized) {
10368 throw new Error("initializeWasm() must be awaited first!");
10370 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
10371 return nativeResponseValue;
10373 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
10375 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
10376 if(!isWasmInitialized) {
10377 throw new Error("initializeWasm() must be awaited first!");
10379 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
10380 return nativeResponseValue;
10382 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
10384 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
10385 if(!isWasmInitialized) {
10386 throw new Error("initializeWasm() must be awaited first!");
10388 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
10389 // debug statements here
10391 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
10393 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
10394 if(!isWasmInitialized) {
10395 throw new Error("initializeWasm() must be awaited first!");
10397 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
10398 return nativeResponseValue;
10400 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
10402 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
10403 if(!isWasmInitialized) {
10404 throw new Error("initializeWasm() must be awaited first!");
10406 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
10407 return nativeResponseValue;
10409 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
10411 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
10412 if(!isWasmInitialized) {
10413 throw new Error("initializeWasm() must be awaited first!");
10415 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
10416 return nativeResponseValue;
10418 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
10420 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
10421 if(!isWasmInitialized) {
10422 throw new Error("initializeWasm() must be awaited first!");
10424 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
10425 // debug statements here
10427 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
10429 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
10430 if(!isWasmInitialized) {
10431 throw new Error("initializeWasm() must be awaited first!");
10433 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
10434 return nativeResponseValue;
10436 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
10438 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
10439 if(!isWasmInitialized) {
10440 throw new Error("initializeWasm() must be awaited first!");
10442 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
10443 return nativeResponseValue;
10445 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
10447 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
10448 if(!isWasmInitialized) {
10449 throw new Error("initializeWasm() must be awaited first!");
10451 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
10452 return nativeResponseValue;
10454 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
10456 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
10457 if(!isWasmInitialized) {
10458 throw new Error("initializeWasm() must be awaited first!");
10460 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
10461 return nativeResponseValue;
10463 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
10465 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
10466 if(!isWasmInitialized) {
10467 throw new Error("initializeWasm() must be awaited first!");
10469 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
10470 return nativeResponseValue;
10472 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
10474 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
10475 if(!isWasmInitialized) {
10476 throw new Error("initializeWasm() must be awaited first!");
10478 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
10479 // debug statements here
10481 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
10483 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
10484 if(!isWasmInitialized) {
10485 throw new Error("initializeWasm() must be awaited first!");
10487 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
10488 return nativeResponseValue;
10490 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
10492 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
10493 if(!isWasmInitialized) {
10494 throw new Error("initializeWasm() must be awaited first!");
10496 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
10497 return nativeResponseValue;
10499 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
10501 export function COption_TypeZ_some(o: number): number {
10502 if(!isWasmInitialized) {
10503 throw new Error("initializeWasm() must be awaited first!");
10505 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
10506 return nativeResponseValue;
10508 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
10510 export function COption_TypeZ_none(): number {
10511 if(!isWasmInitialized) {
10512 throw new Error("initializeWasm() must be awaited first!");
10514 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
10515 return nativeResponseValue;
10517 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
10519 export function COption_TypeZ_free(_res: number): void {
10520 if(!isWasmInitialized) {
10521 throw new Error("initializeWasm() must be awaited first!");
10523 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
10524 // debug statements here
10526 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
10528 export function COption_TypeZ_clone_ptr(arg: number): number {
10529 if(!isWasmInitialized) {
10530 throw new Error("initializeWasm() must be awaited first!");
10532 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
10533 return nativeResponseValue;
10535 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
10537 export function COption_TypeZ_clone(orig: number): number {
10538 if(!isWasmInitialized) {
10539 throw new Error("initializeWasm() must be awaited first!");
10541 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
10542 return nativeResponseValue;
10544 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
10546 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
10547 if(!isWasmInitialized) {
10548 throw new Error("initializeWasm() must be awaited first!");
10550 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
10551 return nativeResponseValue;
10553 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
10555 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
10556 if(!isWasmInitialized) {
10557 throw new Error("initializeWasm() must be awaited first!");
10559 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
10560 return nativeResponseValue;
10562 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
10564 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
10565 if(!isWasmInitialized) {
10566 throw new Error("initializeWasm() must be awaited first!");
10568 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
10569 return nativeResponseValue;
10571 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
10573 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
10574 if(!isWasmInitialized) {
10575 throw new Error("initializeWasm() must be awaited first!");
10577 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
10578 // debug statements here
10580 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
10582 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
10583 if(!isWasmInitialized) {
10584 throw new Error("initializeWasm() must be awaited first!");
10586 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
10587 return nativeResponseValue;
10589 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
10591 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
10592 if(!isWasmInitialized) {
10593 throw new Error("initializeWasm() must be awaited first!");
10595 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
10596 return nativeResponseValue;
10598 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
10600 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
10601 if(!isWasmInitialized) {
10602 throw new Error("initializeWasm() must be awaited first!");
10604 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
10605 return nativeResponseValue;
10607 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
10609 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
10610 if(!isWasmInitialized) {
10611 throw new Error("initializeWasm() must be awaited first!");
10613 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
10614 return nativeResponseValue;
10616 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
10618 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
10619 if(!isWasmInitialized) {
10620 throw new Error("initializeWasm() must be awaited first!");
10622 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
10623 return nativeResponseValue;
10625 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
10627 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
10628 if(!isWasmInitialized) {
10629 throw new Error("initializeWasm() must be awaited first!");
10631 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
10632 // debug statements here
10634 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
10636 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
10637 if(!isWasmInitialized) {
10638 throw new Error("initializeWasm() must be awaited first!");
10640 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
10641 return nativeResponseValue;
10643 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
10645 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
10646 if(!isWasmInitialized) {
10647 throw new Error("initializeWasm() must be awaited first!");
10649 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
10650 return nativeResponseValue;
10652 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
10654 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
10655 if(!isWasmInitialized) {
10656 throw new Error("initializeWasm() must be awaited first!");
10658 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
10659 return nativeResponseValue;
10661 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
10663 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
10664 if(!isWasmInitialized) {
10665 throw new Error("initializeWasm() must be awaited first!");
10667 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
10668 return nativeResponseValue;
10670 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
10672 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
10673 if(!isWasmInitialized) {
10674 throw new Error("initializeWasm() must be awaited first!");
10676 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
10677 return nativeResponseValue;
10679 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
10681 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
10682 if(!isWasmInitialized) {
10683 throw new Error("initializeWasm() must be awaited first!");
10685 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
10686 // debug statements here
10688 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
10690 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
10691 if(!isWasmInitialized) {
10692 throw new Error("initializeWasm() must be awaited first!");
10694 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
10695 return nativeResponseValue;
10697 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
10699 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
10700 if(!isWasmInitialized) {
10701 throw new Error("initializeWasm() must be awaited first!");
10703 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
10704 return nativeResponseValue;
10706 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
10708 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
10709 if(!isWasmInitialized) {
10710 throw new Error("initializeWasm() must be awaited first!");
10712 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
10713 return nativeResponseValue;
10715 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
10717 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
10718 if(!isWasmInitialized) {
10719 throw new Error("initializeWasm() must be awaited first!");
10721 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
10722 return nativeResponseValue;
10724 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
10726 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
10727 if(!isWasmInitialized) {
10728 throw new Error("initializeWasm() must be awaited first!");
10730 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
10731 return nativeResponseValue;
10733 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
10735 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
10736 if(!isWasmInitialized) {
10737 throw new Error("initializeWasm() must be awaited first!");
10739 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
10740 // debug statements here
10742 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
10744 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
10745 if(!isWasmInitialized) {
10746 throw new Error("initializeWasm() must be awaited first!");
10748 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
10749 return nativeResponseValue;
10751 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
10753 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
10754 if(!isWasmInitialized) {
10755 throw new Error("initializeWasm() must be awaited first!");
10757 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
10758 return nativeResponseValue;
10760 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
10762 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
10763 if(!isWasmInitialized) {
10764 throw new Error("initializeWasm() must be awaited first!");
10766 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
10767 return nativeResponseValue;
10769 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
10771 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
10772 if(!isWasmInitialized) {
10773 throw new Error("initializeWasm() must be awaited first!");
10775 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
10776 return nativeResponseValue;
10778 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
10780 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
10781 if(!isWasmInitialized) {
10782 throw new Error("initializeWasm() must be awaited first!");
10784 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
10785 return nativeResponseValue;
10787 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
10789 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
10790 if(!isWasmInitialized) {
10791 throw new Error("initializeWasm() must be awaited first!");
10793 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
10794 // debug statements here
10796 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
10798 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
10799 if(!isWasmInitialized) {
10800 throw new Error("initializeWasm() must be awaited first!");
10802 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
10803 return nativeResponseValue;
10805 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
10807 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
10808 if(!isWasmInitialized) {
10809 throw new Error("initializeWasm() must be awaited first!");
10811 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
10812 return nativeResponseValue;
10814 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
10816 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
10817 if(!isWasmInitialized) {
10818 throw new Error("initializeWasm() must be awaited first!");
10820 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
10821 return nativeResponseValue;
10823 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
10825 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
10826 if(!isWasmInitialized) {
10827 throw new Error("initializeWasm() must be awaited first!");
10829 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
10830 return nativeResponseValue;
10832 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
10834 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
10835 if(!isWasmInitialized) {
10836 throw new Error("initializeWasm() must be awaited first!");
10838 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
10839 return nativeResponseValue;
10841 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
10843 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
10844 if(!isWasmInitialized) {
10845 throw new Error("initializeWasm() must be awaited first!");
10847 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
10848 // debug statements here
10850 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
10852 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
10853 if(!isWasmInitialized) {
10854 throw new Error("initializeWasm() must be awaited first!");
10856 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
10857 return nativeResponseValue;
10859 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
10861 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
10862 if(!isWasmInitialized) {
10863 throw new Error("initializeWasm() must be awaited first!");
10865 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
10866 return nativeResponseValue;
10868 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
10870 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
10871 if(!isWasmInitialized) {
10872 throw new Error("initializeWasm() must be awaited first!");
10874 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
10875 return nativeResponseValue;
10877 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
10879 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
10880 if(!isWasmInitialized) {
10881 throw new Error("initializeWasm() must be awaited first!");
10883 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
10884 // debug statements here
10886 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
10888 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
10889 if(!isWasmInitialized) {
10890 throw new Error("initializeWasm() must be awaited first!");
10892 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
10893 return nativeResponseValue;
10895 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
10897 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
10898 if(!isWasmInitialized) {
10899 throw new Error("initializeWasm() must be awaited first!");
10901 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
10902 return nativeResponseValue;
10904 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
10906 export function CVec_PrivateRouteZ_free(_res: number): void {
10907 if(!isWasmInitialized) {
10908 throw new Error("initializeWasm() must be awaited first!");
10910 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
10911 // debug statements here
10913 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
10915 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
10916 if(!isWasmInitialized) {
10917 throw new Error("initializeWasm() must be awaited first!");
10919 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
10920 return nativeResponseValue;
10922 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
10924 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
10925 if(!isWasmInitialized) {
10926 throw new Error("initializeWasm() must be awaited first!");
10928 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
10929 return nativeResponseValue;
10931 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
10933 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
10934 if(!isWasmInitialized) {
10935 throw new Error("initializeWasm() must be awaited first!");
10937 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
10938 return nativeResponseValue;
10940 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
10942 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
10943 if(!isWasmInitialized) {
10944 throw new Error("initializeWasm() must be awaited first!");
10946 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
10947 // debug statements here
10949 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
10951 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
10952 if(!isWasmInitialized) {
10953 throw new Error("initializeWasm() must be awaited first!");
10955 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
10956 return nativeResponseValue;
10958 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
10960 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
10961 if(!isWasmInitialized) {
10962 throw new Error("initializeWasm() must be awaited first!");
10964 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
10965 return nativeResponseValue;
10967 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
10969 export function CResult_NoneSemanticErrorZ_ok(): number {
10970 if(!isWasmInitialized) {
10971 throw new Error("initializeWasm() must be awaited first!");
10973 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
10974 return nativeResponseValue;
10976 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
10978 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
10979 if(!isWasmInitialized) {
10980 throw new Error("initializeWasm() must be awaited first!");
10982 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
10983 return nativeResponseValue;
10985 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
10987 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
10988 if(!isWasmInitialized) {
10989 throw new Error("initializeWasm() must be awaited first!");
10991 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
10992 return nativeResponseValue;
10994 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
10996 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
10997 if(!isWasmInitialized) {
10998 throw new Error("initializeWasm() must be awaited first!");
11000 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
11001 // debug statements here
11003 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
11005 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
11006 if(!isWasmInitialized) {
11007 throw new Error("initializeWasm() must be awaited first!");
11009 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
11010 return nativeResponseValue;
11012 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
11014 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
11015 if(!isWasmInitialized) {
11016 throw new Error("initializeWasm() must be awaited first!");
11018 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
11019 return nativeResponseValue;
11021 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
11023 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
11024 if(!isWasmInitialized) {
11025 throw new Error("initializeWasm() must be awaited first!");
11027 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
11028 return nativeResponseValue;
11030 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
11032 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
11033 if(!isWasmInitialized) {
11034 throw new Error("initializeWasm() must be awaited first!");
11036 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
11037 return nativeResponseValue;
11039 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
11041 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
11042 if(!isWasmInitialized) {
11043 throw new Error("initializeWasm() must be awaited first!");
11045 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
11046 return nativeResponseValue;
11048 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
11050 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
11051 if(!isWasmInitialized) {
11052 throw new Error("initializeWasm() must be awaited first!");
11054 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
11055 // debug statements here
11057 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
11059 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
11060 if(!isWasmInitialized) {
11061 throw new Error("initializeWasm() must be awaited first!");
11063 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
11064 return nativeResponseValue;
11066 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
11068 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
11069 if(!isWasmInitialized) {
11070 throw new Error("initializeWasm() must be awaited first!");
11072 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
11073 return nativeResponseValue;
11075 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
11077 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
11078 if(!isWasmInitialized) {
11079 throw new Error("initializeWasm() must be awaited first!");
11081 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
11082 return nativeResponseValue;
11084 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
11086 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
11087 if(!isWasmInitialized) {
11088 throw new Error("initializeWasm() must be awaited first!");
11090 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
11091 return nativeResponseValue;
11093 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
11095 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
11096 if(!isWasmInitialized) {
11097 throw new Error("initializeWasm() must be awaited first!");
11099 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
11100 return nativeResponseValue;
11102 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
11104 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
11105 if(!isWasmInitialized) {
11106 throw new Error("initializeWasm() must be awaited first!");
11108 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
11109 // debug statements here
11111 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
11113 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
11114 if(!isWasmInitialized) {
11115 throw new Error("initializeWasm() must be awaited first!");
11117 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
11118 return nativeResponseValue;
11120 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
11122 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
11123 if(!isWasmInitialized) {
11124 throw new Error("initializeWasm() must be awaited first!");
11126 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
11127 return nativeResponseValue;
11129 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
11131 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
11132 if(!isWasmInitialized) {
11133 throw new Error("initializeWasm() must be awaited first!");
11135 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
11136 return nativeResponseValue;
11138 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
11140 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
11141 if(!isWasmInitialized) {
11142 throw new Error("initializeWasm() must be awaited first!");
11144 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
11145 return nativeResponseValue;
11147 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
11149 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
11150 if(!isWasmInitialized) {
11151 throw new Error("initializeWasm() must be awaited first!");
11153 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
11154 return nativeResponseValue;
11156 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
11158 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
11159 if(!isWasmInitialized) {
11160 throw new Error("initializeWasm() must be awaited first!");
11162 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
11163 // debug statements here
11165 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
11167 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
11168 if(!isWasmInitialized) {
11169 throw new Error("initializeWasm() must be awaited first!");
11171 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
11172 return nativeResponseValue;
11174 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
11176 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
11177 if(!isWasmInitialized) {
11178 throw new Error("initializeWasm() must be awaited first!");
11180 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
11181 return nativeResponseValue;
11183 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
11185 export function CResult_StringErrorZ_ok(o: number): number {
11186 if(!isWasmInitialized) {
11187 throw new Error("initializeWasm() must be awaited first!");
11189 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
11190 return nativeResponseValue;
11192 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
11194 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
11195 if(!isWasmInitialized) {
11196 throw new Error("initializeWasm() must be awaited first!");
11198 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
11199 return nativeResponseValue;
11201 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
11203 export function CResult_StringErrorZ_is_ok(o: number): boolean {
11204 if(!isWasmInitialized) {
11205 throw new Error("initializeWasm() must be awaited first!");
11207 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
11208 return nativeResponseValue;
11210 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
11212 export function CResult_StringErrorZ_free(_res: number): void {
11213 if(!isWasmInitialized) {
11214 throw new Error("initializeWasm() must be awaited first!");
11216 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
11217 // debug statements here
11219 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
11221 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
11222 if(!isWasmInitialized) {
11223 throw new Error("initializeWasm() must be awaited first!");
11225 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
11226 return nativeResponseValue;
11228 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
11230 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
11231 if(!isWasmInitialized) {
11232 throw new Error("initializeWasm() must be awaited first!");
11234 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
11235 return nativeResponseValue;
11237 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
11239 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
11240 if(!isWasmInitialized) {
11241 throw new Error("initializeWasm() must be awaited first!");
11243 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
11244 return nativeResponseValue;
11246 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
11248 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
11249 if(!isWasmInitialized) {
11250 throw new Error("initializeWasm() must be awaited first!");
11252 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
11253 // debug statements here
11255 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
11257 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
11258 if(!isWasmInitialized) {
11259 throw new Error("initializeWasm() must be awaited first!");
11261 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
11262 return nativeResponseValue;
11264 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
11266 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
11267 if(!isWasmInitialized) {
11268 throw new Error("initializeWasm() must be awaited first!");
11270 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
11271 return nativeResponseValue;
11273 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
11275 export function COption_MonitorEventZ_some(o: number): number {
11276 if(!isWasmInitialized) {
11277 throw new Error("initializeWasm() must be awaited first!");
11279 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
11280 return nativeResponseValue;
11282 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
11284 export function COption_MonitorEventZ_none(): number {
11285 if(!isWasmInitialized) {
11286 throw new Error("initializeWasm() must be awaited first!");
11288 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
11289 return nativeResponseValue;
11291 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
11293 export function COption_MonitorEventZ_free(_res: number): void {
11294 if(!isWasmInitialized) {
11295 throw new Error("initializeWasm() must be awaited first!");
11297 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
11298 // debug statements here
11300 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
11302 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
11303 if(!isWasmInitialized) {
11304 throw new Error("initializeWasm() must be awaited first!");
11306 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
11307 return nativeResponseValue;
11309 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
11311 export function COption_MonitorEventZ_clone(orig: number): number {
11312 if(!isWasmInitialized) {
11313 throw new Error("initializeWasm() must be awaited first!");
11315 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
11316 return nativeResponseValue;
11318 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
11320 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
11321 if(!isWasmInitialized) {
11322 throw new Error("initializeWasm() must be awaited first!");
11324 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
11325 return nativeResponseValue;
11327 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
11329 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
11330 if(!isWasmInitialized) {
11331 throw new Error("initializeWasm() must be awaited first!");
11333 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
11334 return nativeResponseValue;
11336 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
11338 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
11339 if(!isWasmInitialized) {
11340 throw new Error("initializeWasm() must be awaited first!");
11342 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
11343 return nativeResponseValue;
11345 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
11347 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
11348 if(!isWasmInitialized) {
11349 throw new Error("initializeWasm() must be awaited first!");
11351 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
11352 // debug statements here
11354 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
11356 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
11357 if(!isWasmInitialized) {
11358 throw new Error("initializeWasm() must be awaited first!");
11360 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
11361 return nativeResponseValue;
11363 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
11365 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
11366 if(!isWasmInitialized) {
11367 throw new Error("initializeWasm() must be awaited first!");
11369 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
11370 return nativeResponseValue;
11372 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
11374 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
11375 if(!isWasmInitialized) {
11376 throw new Error("initializeWasm() must be awaited first!");
11378 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
11379 return nativeResponseValue;
11381 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
11383 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
11384 if(!isWasmInitialized) {
11385 throw new Error("initializeWasm() must be awaited first!");
11387 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
11388 return nativeResponseValue;
11390 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
11392 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
11393 if(!isWasmInitialized) {
11394 throw new Error("initializeWasm() must be awaited first!");
11396 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
11397 return nativeResponseValue;
11399 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
11401 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
11402 if(!isWasmInitialized) {
11403 throw new Error("initializeWasm() must be awaited first!");
11405 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
11406 // debug statements here
11408 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
11410 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
11411 if(!isWasmInitialized) {
11412 throw new Error("initializeWasm() must be awaited first!");
11414 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
11415 return nativeResponseValue;
11417 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
11419 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
11420 if(!isWasmInitialized) {
11421 throw new Error("initializeWasm() must be awaited first!");
11423 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
11424 return nativeResponseValue;
11426 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
11428 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
11429 if(!isWasmInitialized) {
11430 throw new Error("initializeWasm() must be awaited first!");
11432 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
11433 return nativeResponseValue;
11435 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
11437 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
11438 if(!isWasmInitialized) {
11439 throw new Error("initializeWasm() must be awaited first!");
11441 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
11442 return nativeResponseValue;
11444 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
11446 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
11447 if(!isWasmInitialized) {
11448 throw new Error("initializeWasm() must be awaited first!");
11450 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
11451 return nativeResponseValue;
11453 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
11455 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
11456 if(!isWasmInitialized) {
11457 throw new Error("initializeWasm() must be awaited first!");
11459 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
11460 // debug statements here
11462 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
11464 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
11465 if(!isWasmInitialized) {
11466 throw new Error("initializeWasm() must be awaited first!");
11468 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
11469 return nativeResponseValue;
11471 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
11473 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
11474 if(!isWasmInitialized) {
11475 throw new Error("initializeWasm() must be awaited first!");
11477 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
11478 return nativeResponseValue;
11480 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
11482 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
11483 if(!isWasmInitialized) {
11484 throw new Error("initializeWasm() must be awaited first!");
11486 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
11487 return nativeResponseValue;
11489 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
11491 export function C2Tuple_u32ScriptZ_free(_res: number): void {
11492 if(!isWasmInitialized) {
11493 throw new Error("initializeWasm() must be awaited first!");
11495 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
11496 // debug statements here
11498 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
11500 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
11501 if(!isWasmInitialized) {
11502 throw new Error("initializeWasm() must be awaited first!");
11504 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
11505 // debug statements here
11507 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
11509 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
11510 if(!isWasmInitialized) {
11511 throw new Error("initializeWasm() must be awaited first!");
11513 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
11514 return nativeResponseValue;
11516 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
11518 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
11519 if(!isWasmInitialized) {
11520 throw new Error("initializeWasm() must be awaited first!");
11522 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
11523 return nativeResponseValue;
11525 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
11527 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
11528 if(!isWasmInitialized) {
11529 throw new Error("initializeWasm() must be awaited first!");
11531 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
11532 return nativeResponseValue;
11534 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
11536 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
11537 if(!isWasmInitialized) {
11538 throw new Error("initializeWasm() must be awaited first!");
11540 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
11541 // debug statements here
11543 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
11545 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
11546 if(!isWasmInitialized) {
11547 throw new Error("initializeWasm() must be awaited first!");
11549 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
11550 // debug statements here
11552 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
11554 export function CVec_EventZ_free(_res: number): void {
11555 if(!isWasmInitialized) {
11556 throw new Error("initializeWasm() must be awaited first!");
11558 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
11559 // debug statements here
11561 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
11563 export function CVec_TransactionZ_free(_res: number): void {
11564 if(!isWasmInitialized) {
11565 throw new Error("initializeWasm() must be awaited first!");
11567 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
11568 // debug statements here
11570 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
11572 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
11573 if(!isWasmInitialized) {
11574 throw new Error("initializeWasm() must be awaited first!");
11576 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
11577 return nativeResponseValue;
11579 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
11581 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
11582 if(!isWasmInitialized) {
11583 throw new Error("initializeWasm() must be awaited first!");
11585 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
11586 return nativeResponseValue;
11588 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
11590 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
11591 if(!isWasmInitialized) {
11592 throw new Error("initializeWasm() must be awaited first!");
11594 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
11595 return nativeResponseValue;
11597 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
11599 export function C2Tuple_u32TxOutZ_free(_res: number): void {
11600 if(!isWasmInitialized) {
11601 throw new Error("initializeWasm() must be awaited first!");
11603 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
11604 // debug statements here
11606 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
11608 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
11609 if(!isWasmInitialized) {
11610 throw new Error("initializeWasm() must be awaited first!");
11612 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
11613 // debug statements here
11615 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
11617 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
11618 if(!isWasmInitialized) {
11619 throw new Error("initializeWasm() must be awaited first!");
11621 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
11622 return nativeResponseValue;
11624 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
11626 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
11627 if(!isWasmInitialized) {
11628 throw new Error("initializeWasm() must be awaited first!");
11630 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
11631 return nativeResponseValue;
11633 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
11635 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
11636 if(!isWasmInitialized) {
11637 throw new Error("initializeWasm() must be awaited first!");
11639 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
11640 return nativeResponseValue;
11642 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
11644 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
11645 if(!isWasmInitialized) {
11646 throw new Error("initializeWasm() must be awaited first!");
11648 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
11649 // debug statements here
11651 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
11653 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
11654 if(!isWasmInitialized) {
11655 throw new Error("initializeWasm() must be awaited first!");
11657 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
11658 // debug statements here
11660 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
11662 export function CVec_BalanceZ_free(_res: number): void {
11663 if(!isWasmInitialized) {
11664 throw new Error("initializeWasm() must be awaited first!");
11666 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
11667 // debug statements here
11669 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
11671 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
11672 if(!isWasmInitialized) {
11673 throw new Error("initializeWasm() must be awaited first!");
11675 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
11676 return nativeResponseValue;
11678 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
11680 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
11681 if(!isWasmInitialized) {
11682 throw new Error("initializeWasm() must be awaited first!");
11684 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
11685 return nativeResponseValue;
11687 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
11689 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
11690 if(!isWasmInitialized) {
11691 throw new Error("initializeWasm() must be awaited first!");
11693 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
11694 return nativeResponseValue;
11696 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
11698 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
11699 if(!isWasmInitialized) {
11700 throw new Error("initializeWasm() must be awaited first!");
11702 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
11703 // debug statements here
11705 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
11707 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
11708 if(!isWasmInitialized) {
11709 throw new Error("initializeWasm() must be awaited first!");
11711 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
11712 return nativeResponseValue;
11714 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
11716 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
11717 if(!isWasmInitialized) {
11718 throw new Error("initializeWasm() must be awaited first!");
11720 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
11721 return nativeResponseValue;
11723 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
11725 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
11726 if(!isWasmInitialized) {
11727 throw new Error("initializeWasm() must be awaited first!");
11729 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
11730 return nativeResponseValue;
11732 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
11734 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
11735 if(!isWasmInitialized) {
11736 throw new Error("initializeWasm() must be awaited first!");
11738 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
11739 // debug statements here
11741 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
11743 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
11744 if(!isWasmInitialized) {
11745 throw new Error("initializeWasm() must be awaited first!");
11747 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
11748 return nativeResponseValue;
11750 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
11752 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
11753 if(!isWasmInitialized) {
11754 throw new Error("initializeWasm() must be awaited first!");
11756 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
11757 return nativeResponseValue;
11759 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
11761 export function CResult_NoneLightningErrorZ_ok(): number {
11762 if(!isWasmInitialized) {
11763 throw new Error("initializeWasm() must be awaited first!");
11765 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
11766 return nativeResponseValue;
11768 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
11770 export function CResult_NoneLightningErrorZ_err(e: number): number {
11771 if(!isWasmInitialized) {
11772 throw new Error("initializeWasm() must be awaited first!");
11774 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
11775 return nativeResponseValue;
11777 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
11779 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
11780 if(!isWasmInitialized) {
11781 throw new Error("initializeWasm() must be awaited first!");
11783 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
11784 return nativeResponseValue;
11786 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
11788 export function CResult_NoneLightningErrorZ_free(_res: number): void {
11789 if(!isWasmInitialized) {
11790 throw new Error("initializeWasm() must be awaited first!");
11792 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
11793 // debug statements here
11795 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
11797 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
11798 if(!isWasmInitialized) {
11799 throw new Error("initializeWasm() must be awaited first!");
11801 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
11802 return nativeResponseValue;
11804 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
11806 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
11807 if(!isWasmInitialized) {
11808 throw new Error("initializeWasm() must be awaited first!");
11810 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
11811 return nativeResponseValue;
11813 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
11815 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
11816 if(!isWasmInitialized) {
11817 throw new Error("initializeWasm() must be awaited first!");
11819 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
11820 return nativeResponseValue;
11822 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
11824 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
11825 if(!isWasmInitialized) {
11826 throw new Error("initializeWasm() must be awaited first!");
11828 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
11829 return nativeResponseValue;
11831 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
11833 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
11834 if(!isWasmInitialized) {
11835 throw new Error("initializeWasm() must be awaited first!");
11837 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
11838 return nativeResponseValue;
11840 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
11842 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
11843 if(!isWasmInitialized) {
11844 throw new Error("initializeWasm() must be awaited first!");
11846 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
11847 // debug statements here
11849 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
11851 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
11852 if(!isWasmInitialized) {
11853 throw new Error("initializeWasm() must be awaited first!");
11855 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
11856 // debug statements here
11858 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
11860 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
11861 if(!isWasmInitialized) {
11862 throw new Error("initializeWasm() must be awaited first!");
11864 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
11865 return nativeResponseValue;
11867 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
11869 export function CResult_boolLightningErrorZ_err(e: number): number {
11870 if(!isWasmInitialized) {
11871 throw new Error("initializeWasm() must be awaited first!");
11873 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
11874 return nativeResponseValue;
11876 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
11878 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
11879 if(!isWasmInitialized) {
11880 throw new Error("initializeWasm() must be awaited first!");
11882 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
11883 return nativeResponseValue;
11885 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
11887 export function CResult_boolLightningErrorZ_free(_res: number): void {
11888 if(!isWasmInitialized) {
11889 throw new Error("initializeWasm() must be awaited first!");
11891 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
11892 // debug statements here
11894 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
11896 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
11897 if(!isWasmInitialized) {
11898 throw new Error("initializeWasm() must be awaited first!");
11900 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
11901 return nativeResponseValue;
11903 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
11905 export function CResult_boolLightningErrorZ_clone(orig: number): number {
11906 if(!isWasmInitialized) {
11907 throw new Error("initializeWasm() must be awaited first!");
11909 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
11910 return nativeResponseValue;
11912 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
11914 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
11915 if(!isWasmInitialized) {
11916 throw new Error("initializeWasm() must be awaited first!");
11918 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
11919 return nativeResponseValue;
11921 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
11923 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
11924 if(!isWasmInitialized) {
11925 throw new Error("initializeWasm() must be awaited first!");
11927 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
11928 return nativeResponseValue;
11930 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
11932 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
11933 if(!isWasmInitialized) {
11934 throw new Error("initializeWasm() must be awaited first!");
11936 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
11937 return nativeResponseValue;
11939 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
11941 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
11942 if(!isWasmInitialized) {
11943 throw new Error("initializeWasm() must be awaited first!");
11945 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
11946 // debug statements here
11948 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
11950 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
11951 if(!isWasmInitialized) {
11952 throw new Error("initializeWasm() must be awaited first!");
11954 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
11955 // debug statements here
11957 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
11959 export function CVec_NodeAnnouncementZ_free(_res: number): void {
11960 if(!isWasmInitialized) {
11961 throw new Error("initializeWasm() must be awaited first!");
11963 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
11964 // debug statements here
11966 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
11968 export function CVec_PublicKeyZ_free(_res: number): void {
11969 if(!isWasmInitialized) {
11970 throw new Error("initializeWasm() must be awaited first!");
11972 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
11973 // debug statements here
11975 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
11977 export function COption_NetAddressZ_some(o: number): number {
11978 if(!isWasmInitialized) {
11979 throw new Error("initializeWasm() must be awaited first!");
11981 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
11982 return nativeResponseValue;
11984 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
11986 export function COption_NetAddressZ_none(): number {
11987 if(!isWasmInitialized) {
11988 throw new Error("initializeWasm() must be awaited first!");
11990 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
11991 return nativeResponseValue;
11993 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
11995 export function COption_NetAddressZ_free(_res: number): void {
11996 if(!isWasmInitialized) {
11997 throw new Error("initializeWasm() must be awaited first!");
11999 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
12000 // debug statements here
12002 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
12004 export function COption_NetAddressZ_clone_ptr(arg: number): number {
12005 if(!isWasmInitialized) {
12006 throw new Error("initializeWasm() must be awaited first!");
12008 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
12009 return nativeResponseValue;
12011 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
12013 export function COption_NetAddressZ_clone(orig: number): number {
12014 if(!isWasmInitialized) {
12015 throw new Error("initializeWasm() must be awaited first!");
12017 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
12018 return nativeResponseValue;
12020 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
12022 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
12023 if(!isWasmInitialized) {
12024 throw new Error("initializeWasm() must be awaited first!");
12026 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
12027 return nativeResponseValue;
12029 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12031 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
12032 if(!isWasmInitialized) {
12033 throw new Error("initializeWasm() must be awaited first!");
12035 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
12036 return nativeResponseValue;
12038 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
12040 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
12041 if(!isWasmInitialized) {
12042 throw new Error("initializeWasm() must be awaited first!");
12044 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
12045 return nativeResponseValue;
12047 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
12049 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
12050 if(!isWasmInitialized) {
12051 throw new Error("initializeWasm() must be awaited first!");
12053 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
12054 // debug statements here
12056 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
12058 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
12059 if(!isWasmInitialized) {
12060 throw new Error("initializeWasm() must be awaited first!");
12062 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
12063 return nativeResponseValue;
12065 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
12067 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
12068 if(!isWasmInitialized) {
12069 throw new Error("initializeWasm() must be awaited first!");
12071 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
12072 return nativeResponseValue;
12074 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
12076 export function CResult_NonePeerHandleErrorZ_ok(): number {
12077 if(!isWasmInitialized) {
12078 throw new Error("initializeWasm() must be awaited first!");
12080 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
12081 return nativeResponseValue;
12083 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
12085 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
12086 if(!isWasmInitialized) {
12087 throw new Error("initializeWasm() must be awaited first!");
12089 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
12090 return nativeResponseValue;
12092 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
12094 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
12095 if(!isWasmInitialized) {
12096 throw new Error("initializeWasm() must be awaited first!");
12098 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
12099 return nativeResponseValue;
12101 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
12103 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
12104 if(!isWasmInitialized) {
12105 throw new Error("initializeWasm() must be awaited first!");
12107 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
12108 // debug statements here
12110 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
12112 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
12113 if(!isWasmInitialized) {
12114 throw new Error("initializeWasm() must be awaited first!");
12116 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
12117 return nativeResponseValue;
12119 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
12121 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
12122 if(!isWasmInitialized) {
12123 throw new Error("initializeWasm() must be awaited first!");
12125 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
12126 return nativeResponseValue;
12128 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
12130 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
12131 if(!isWasmInitialized) {
12132 throw new Error("initializeWasm() must be awaited first!");
12134 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
12135 return nativeResponseValue;
12137 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12139 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
12140 if(!isWasmInitialized) {
12141 throw new Error("initializeWasm() must be awaited first!");
12143 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
12144 return nativeResponseValue;
12146 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
12148 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
12149 if(!isWasmInitialized) {
12150 throw new Error("initializeWasm() must be awaited first!");
12152 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
12153 return nativeResponseValue;
12155 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
12157 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
12158 if(!isWasmInitialized) {
12159 throw new Error("initializeWasm() must be awaited first!");
12161 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
12162 // debug statements here
12164 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
12166 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
12167 if(!isWasmInitialized) {
12168 throw new Error("initializeWasm() must be awaited first!");
12170 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
12171 return nativeResponseValue;
12173 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
12175 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
12176 if(!isWasmInitialized) {
12177 throw new Error("initializeWasm() must be awaited first!");
12179 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
12180 return nativeResponseValue;
12182 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
12184 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
12185 if(!isWasmInitialized) {
12186 throw new Error("initializeWasm() must be awaited first!");
12188 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
12189 return nativeResponseValue;
12191 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
12193 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
12194 if(!isWasmInitialized) {
12195 throw new Error("initializeWasm() must be awaited first!");
12197 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
12198 return nativeResponseValue;
12200 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
12202 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
12203 if(!isWasmInitialized) {
12204 throw new Error("initializeWasm() must be awaited first!");
12206 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
12207 return nativeResponseValue;
12209 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
12211 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
12212 if(!isWasmInitialized) {
12213 throw new Error("initializeWasm() must be awaited first!");
12215 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
12216 // debug statements here
12218 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
12220 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
12221 if(!isWasmInitialized) {
12222 throw new Error("initializeWasm() must be awaited first!");
12224 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
12225 return nativeResponseValue;
12227 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
12229 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
12230 if(!isWasmInitialized) {
12231 throw new Error("initializeWasm() must be awaited first!");
12233 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
12234 return nativeResponseValue;
12236 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
12238 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
12239 if(!isWasmInitialized) {
12240 throw new Error("initializeWasm() must be awaited first!");
12242 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
12243 return nativeResponseValue;
12245 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
12247 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
12248 if(!isWasmInitialized) {
12249 throw new Error("initializeWasm() must be awaited first!");
12251 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
12252 return nativeResponseValue;
12254 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
12256 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
12257 if(!isWasmInitialized) {
12258 throw new Error("initializeWasm() must be awaited first!");
12260 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
12261 return nativeResponseValue;
12263 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
12265 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
12266 if(!isWasmInitialized) {
12267 throw new Error("initializeWasm() must be awaited first!");
12269 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
12270 // debug statements here
12272 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
12274 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
12275 if(!isWasmInitialized) {
12276 throw new Error("initializeWasm() must be awaited first!");
12278 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
12279 return nativeResponseValue;
12281 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
12283 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
12284 if(!isWasmInitialized) {
12285 throw new Error("initializeWasm() must be awaited first!");
12287 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
12288 return nativeResponseValue;
12290 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
12292 export function COption_AccessZ_some(o: number): number {
12293 if(!isWasmInitialized) {
12294 throw new Error("initializeWasm() must be awaited first!");
12296 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
12297 return nativeResponseValue;
12299 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
12301 export function COption_AccessZ_none(): number {
12302 if(!isWasmInitialized) {
12303 throw new Error("initializeWasm() must be awaited first!");
12305 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
12306 return nativeResponseValue;
12308 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
12310 export function COption_AccessZ_free(_res: number): void {
12311 if(!isWasmInitialized) {
12312 throw new Error("initializeWasm() must be awaited first!");
12314 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
12315 // debug statements here
12317 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
12319 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
12320 if(!isWasmInitialized) {
12321 throw new Error("initializeWasm() must be awaited first!");
12323 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
12324 return nativeResponseValue;
12326 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
12328 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
12329 if(!isWasmInitialized) {
12330 throw new Error("initializeWasm() must be awaited first!");
12332 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
12333 return nativeResponseValue;
12335 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
12337 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
12338 if(!isWasmInitialized) {
12339 throw new Error("initializeWasm() must be awaited first!");
12341 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
12342 return nativeResponseValue;
12344 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
12346 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
12347 if(!isWasmInitialized) {
12348 throw new Error("initializeWasm() must be awaited first!");
12350 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
12351 // debug statements here
12353 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
12355 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
12356 if(!isWasmInitialized) {
12357 throw new Error("initializeWasm() must be awaited first!");
12359 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
12360 return nativeResponseValue;
12362 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
12364 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
12365 if(!isWasmInitialized) {
12366 throw new Error("initializeWasm() must be awaited first!");
12368 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
12369 return nativeResponseValue;
12371 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
12373 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
12374 if(!isWasmInitialized) {
12375 throw new Error("initializeWasm() must be awaited first!");
12377 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
12378 return nativeResponseValue;
12380 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
12382 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
12383 if(!isWasmInitialized) {
12384 throw new Error("initializeWasm() must be awaited first!");
12386 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
12387 return nativeResponseValue;
12389 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
12391 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
12392 if(!isWasmInitialized) {
12393 throw new Error("initializeWasm() must be awaited first!");
12395 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
12396 return nativeResponseValue;
12398 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
12400 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
12401 if(!isWasmInitialized) {
12402 throw new Error("initializeWasm() must be awaited first!");
12404 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
12405 // debug statements here
12407 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
12409 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
12410 if(!isWasmInitialized) {
12411 throw new Error("initializeWasm() must be awaited first!");
12413 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
12414 return nativeResponseValue;
12416 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
12418 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
12419 if(!isWasmInitialized) {
12420 throw new Error("initializeWasm() must be awaited first!");
12422 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
12423 return nativeResponseValue;
12425 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
12427 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
12428 if(!isWasmInitialized) {
12429 throw new Error("initializeWasm() must be awaited first!");
12431 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
12432 return nativeResponseValue;
12434 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
12436 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
12437 if(!isWasmInitialized) {
12438 throw new Error("initializeWasm() must be awaited first!");
12440 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
12441 return nativeResponseValue;
12443 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
12445 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
12446 if(!isWasmInitialized) {
12447 throw new Error("initializeWasm() must be awaited first!");
12449 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
12450 return nativeResponseValue;
12452 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
12454 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
12455 if(!isWasmInitialized) {
12456 throw new Error("initializeWasm() must be awaited first!");
12458 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
12459 // debug statements here
12461 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
12463 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
12464 if(!isWasmInitialized) {
12465 throw new Error("initializeWasm() must be awaited first!");
12467 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
12468 return nativeResponseValue;
12470 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
12472 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
12473 if(!isWasmInitialized) {
12474 throw new Error("initializeWasm() must be awaited first!");
12476 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
12477 return nativeResponseValue;
12479 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
12481 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
12482 if(!isWasmInitialized) {
12483 throw new Error("initializeWasm() must be awaited first!");
12485 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
12486 return nativeResponseValue;
12488 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
12490 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
12491 if(!isWasmInitialized) {
12492 throw new Error("initializeWasm() must be awaited first!");
12494 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
12495 return nativeResponseValue;
12497 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
12499 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
12500 if(!isWasmInitialized) {
12501 throw new Error("initializeWasm() must be awaited first!");
12503 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
12504 return nativeResponseValue;
12506 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
12508 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
12509 if(!isWasmInitialized) {
12510 throw new Error("initializeWasm() must be awaited first!");
12512 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
12513 // debug statements here
12515 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
12517 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
12518 if(!isWasmInitialized) {
12519 throw new Error("initializeWasm() must be awaited first!");
12521 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
12522 return nativeResponseValue;
12524 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
12526 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
12527 if(!isWasmInitialized) {
12528 throw new Error("initializeWasm() must be awaited first!");
12530 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
12531 return nativeResponseValue;
12533 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
12535 export function CVec_u64Z_free(_res: number): void {
12536 if(!isWasmInitialized) {
12537 throw new Error("initializeWasm() must be awaited first!");
12539 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
12540 // debug statements here
12542 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
12544 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
12545 if(!isWasmInitialized) {
12546 throw new Error("initializeWasm() must be awaited first!");
12548 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
12549 return nativeResponseValue;
12551 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
12553 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
12554 if(!isWasmInitialized) {
12555 throw new Error("initializeWasm() must be awaited first!");
12557 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
12558 return nativeResponseValue;
12560 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
12562 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
12563 if(!isWasmInitialized) {
12564 throw new Error("initializeWasm() must be awaited first!");
12566 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
12567 return nativeResponseValue;
12569 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
12571 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
12572 if(!isWasmInitialized) {
12573 throw new Error("initializeWasm() must be awaited first!");
12575 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
12576 // debug statements here
12578 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
12580 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
12581 if(!isWasmInitialized) {
12582 throw new Error("initializeWasm() must be awaited first!");
12584 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
12585 return nativeResponseValue;
12587 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
12589 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
12590 if(!isWasmInitialized) {
12591 throw new Error("initializeWasm() must be awaited first!");
12593 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
12594 return nativeResponseValue;
12596 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
12598 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
12599 if(!isWasmInitialized) {
12600 throw new Error("initializeWasm() must be awaited first!");
12602 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
12603 return nativeResponseValue;
12605 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
12607 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
12608 if(!isWasmInitialized) {
12609 throw new Error("initializeWasm() must be awaited first!");
12611 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
12612 return nativeResponseValue;
12614 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
12616 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
12617 if(!isWasmInitialized) {
12618 throw new Error("initializeWasm() must be awaited first!");
12620 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
12621 return nativeResponseValue;
12623 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
12625 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
12626 if(!isWasmInitialized) {
12627 throw new Error("initializeWasm() must be awaited first!");
12629 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
12630 // debug statements here
12632 // uintptr_t CResult_NetworkGraphDecodeErrorZ_clone_ptr(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR arg);
12634 export function CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg: number): number {
12635 if(!isWasmInitialized) {
12636 throw new Error("initializeWasm() must be awaited first!");
12638 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone_ptr(arg);
12639 return nativeResponseValue;
12641 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
12643 export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
12644 if(!isWasmInitialized) {
12645 throw new Error("initializeWasm() must be awaited first!");
12647 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_clone(orig);
12648 return nativeResponseValue;
12650 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
12652 export function COption_CVec_NetAddressZZ_some(o: number): number {
12653 if(!isWasmInitialized) {
12654 throw new Error("initializeWasm() must be awaited first!");
12656 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
12657 return nativeResponseValue;
12659 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
12661 export function COption_CVec_NetAddressZZ_none(): number {
12662 if(!isWasmInitialized) {
12663 throw new Error("initializeWasm() must be awaited first!");
12665 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
12666 return nativeResponseValue;
12668 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
12670 export function COption_CVec_NetAddressZZ_free(_res: number): void {
12671 if(!isWasmInitialized) {
12672 throw new Error("initializeWasm() must be awaited first!");
12674 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
12675 // debug statements here
12677 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
12679 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
12680 if(!isWasmInitialized) {
12681 throw new Error("initializeWasm() must be awaited first!");
12683 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
12684 return nativeResponseValue;
12686 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
12688 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
12689 if(!isWasmInitialized) {
12690 throw new Error("initializeWasm() must be awaited first!");
12692 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
12693 return nativeResponseValue;
12695 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
12697 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
12698 if(!isWasmInitialized) {
12699 throw new Error("initializeWasm() must be awaited first!");
12701 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
12702 return nativeResponseValue;
12704 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
12706 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
12707 if(!isWasmInitialized) {
12708 throw new Error("initializeWasm() must be awaited first!");
12710 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
12711 return nativeResponseValue;
12713 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
12715 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
12716 if(!isWasmInitialized) {
12717 throw new Error("initializeWasm() must be awaited first!");
12719 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
12720 return nativeResponseValue;
12722 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
12724 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
12725 if(!isWasmInitialized) {
12726 throw new Error("initializeWasm() must be awaited first!");
12728 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
12729 // debug statements here
12731 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
12733 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
12734 if(!isWasmInitialized) {
12735 throw new Error("initializeWasm() must be awaited first!");
12737 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
12738 return nativeResponseValue;
12740 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
12742 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
12743 if(!isWasmInitialized) {
12744 throw new Error("initializeWasm() must be awaited first!");
12746 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
12747 return nativeResponseValue;
12749 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
12751 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
12752 if(!isWasmInitialized) {
12753 throw new Error("initializeWasm() must be awaited first!");
12755 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
12756 // debug statements here
12758 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
12760 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
12761 if(!isWasmInitialized) {
12762 throw new Error("initializeWasm() must be awaited first!");
12764 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
12765 // debug statements here
12767 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
12769 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
12770 if(!isWasmInitialized) {
12771 throw new Error("initializeWasm() must be awaited first!");
12773 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
12774 // debug statements here
12776 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
12778 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
12779 if(!isWasmInitialized) {
12780 throw new Error("initializeWasm() must be awaited first!");
12782 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
12783 // debug statements here
12785 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
12787 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
12788 if(!isWasmInitialized) {
12789 throw new Error("initializeWasm() must be awaited first!");
12791 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
12792 return nativeResponseValue;
12794 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
12796 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
12797 if(!isWasmInitialized) {
12798 throw new Error("initializeWasm() must be awaited first!");
12800 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
12801 return nativeResponseValue;
12803 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
12805 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
12806 if(!isWasmInitialized) {
12807 throw new Error("initializeWasm() must be awaited first!");
12809 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
12810 return nativeResponseValue;
12812 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
12814 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
12815 if(!isWasmInitialized) {
12816 throw new Error("initializeWasm() must be awaited first!");
12818 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
12819 // debug statements here
12821 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
12823 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
12824 if(!isWasmInitialized) {
12825 throw new Error("initializeWasm() must be awaited first!");
12827 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
12828 return nativeResponseValue;
12830 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
12832 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
12833 if(!isWasmInitialized) {
12834 throw new Error("initializeWasm() must be awaited first!");
12836 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
12837 return nativeResponseValue;
12839 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
12841 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
12842 if(!isWasmInitialized) {
12843 throw new Error("initializeWasm() must be awaited first!");
12845 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
12846 return nativeResponseValue;
12848 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
12850 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
12851 if(!isWasmInitialized) {
12852 throw new Error("initializeWasm() must be awaited first!");
12854 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
12855 return nativeResponseValue;
12857 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
12859 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
12860 if(!isWasmInitialized) {
12861 throw new Error("initializeWasm() must be awaited first!");
12863 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
12864 return nativeResponseValue;
12866 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
12868 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
12869 if(!isWasmInitialized) {
12870 throw new Error("initializeWasm() must be awaited first!");
12872 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
12873 // debug statements here
12875 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
12877 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
12878 if(!isWasmInitialized) {
12879 throw new Error("initializeWasm() must be awaited first!");
12881 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
12882 return nativeResponseValue;
12884 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
12886 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
12887 if(!isWasmInitialized) {
12888 throw new Error("initializeWasm() must be awaited first!");
12890 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
12891 return nativeResponseValue;
12893 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
12895 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
12896 if(!isWasmInitialized) {
12897 throw new Error("initializeWasm() must be awaited first!");
12899 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
12900 return nativeResponseValue;
12902 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
12904 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
12905 if(!isWasmInitialized) {
12906 throw new Error("initializeWasm() must be awaited first!");
12908 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
12909 return nativeResponseValue;
12911 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
12913 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
12914 if(!isWasmInitialized) {
12915 throw new Error("initializeWasm() must be awaited first!");
12917 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
12918 return nativeResponseValue;
12920 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
12922 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
12923 if(!isWasmInitialized) {
12924 throw new Error("initializeWasm() must be awaited first!");
12926 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
12927 // debug statements here
12929 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
12931 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
12932 if(!isWasmInitialized) {
12933 throw new Error("initializeWasm() must be awaited first!");
12935 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
12936 return nativeResponseValue;
12938 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
12940 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
12941 if(!isWasmInitialized) {
12942 throw new Error("initializeWasm() must be awaited first!");
12944 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
12945 return nativeResponseValue;
12947 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
12949 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
12950 if(!isWasmInitialized) {
12951 throw new Error("initializeWasm() must be awaited first!");
12953 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
12954 return nativeResponseValue;
12956 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
12958 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
12959 if(!isWasmInitialized) {
12960 throw new Error("initializeWasm() must be awaited first!");
12962 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
12963 return nativeResponseValue;
12965 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
12967 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
12968 if(!isWasmInitialized) {
12969 throw new Error("initializeWasm() must be awaited first!");
12971 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
12972 return nativeResponseValue;
12974 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
12976 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
12977 if(!isWasmInitialized) {
12978 throw new Error("initializeWasm() must be awaited first!");
12980 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
12981 // debug statements here
12983 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
12985 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
12986 if(!isWasmInitialized) {
12987 throw new Error("initializeWasm() must be awaited first!");
12989 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
12990 return nativeResponseValue;
12992 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
12994 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
12995 if(!isWasmInitialized) {
12996 throw new Error("initializeWasm() must be awaited first!");
12998 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
12999 return nativeResponseValue;
13001 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13003 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13004 if(!isWasmInitialized) {
13005 throw new Error("initializeWasm() must be awaited first!");
13007 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13008 return nativeResponseValue;
13010 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13012 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13013 if(!isWasmInitialized) {
13014 throw new Error("initializeWasm() must be awaited first!");
13016 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13017 return nativeResponseValue;
13019 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13021 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13022 if(!isWasmInitialized) {
13023 throw new Error("initializeWasm() must be awaited first!");
13025 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13026 return nativeResponseValue;
13028 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13030 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13031 if(!isWasmInitialized) {
13032 throw new Error("initializeWasm() must be awaited first!");
13034 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13035 // debug statements here
13037 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13039 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13040 if(!isWasmInitialized) {
13041 throw new Error("initializeWasm() must be awaited first!");
13043 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13044 return nativeResponseValue;
13046 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13048 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13049 if(!isWasmInitialized) {
13050 throw new Error("initializeWasm() must be awaited first!");
13052 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13053 return nativeResponseValue;
13055 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13057 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13058 if(!isWasmInitialized) {
13059 throw new Error("initializeWasm() must be awaited first!");
13061 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13062 return nativeResponseValue;
13064 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13066 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13067 if(!isWasmInitialized) {
13068 throw new Error("initializeWasm() must be awaited first!");
13070 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13071 return nativeResponseValue;
13073 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13075 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13076 if(!isWasmInitialized) {
13077 throw new Error("initializeWasm() must be awaited first!");
13079 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13080 return nativeResponseValue;
13082 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13084 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13085 if(!isWasmInitialized) {
13086 throw new Error("initializeWasm() must be awaited first!");
13088 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13089 // debug statements here
13091 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13093 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13094 if(!isWasmInitialized) {
13095 throw new Error("initializeWasm() must be awaited first!");
13097 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13098 return nativeResponseValue;
13100 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13102 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13103 if(!isWasmInitialized) {
13104 throw new Error("initializeWasm() must be awaited first!");
13106 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13107 return nativeResponseValue;
13109 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13111 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13112 if(!isWasmInitialized) {
13113 throw new Error("initializeWasm() must be awaited first!");
13115 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13116 return nativeResponseValue;
13118 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
13120 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
13121 if(!isWasmInitialized) {
13122 throw new Error("initializeWasm() must be awaited first!");
13124 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
13125 return nativeResponseValue;
13127 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
13129 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
13130 if(!isWasmInitialized) {
13131 throw new Error("initializeWasm() must be awaited first!");
13133 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
13134 return nativeResponseValue;
13136 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
13138 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
13139 if(!isWasmInitialized) {
13140 throw new Error("initializeWasm() must be awaited first!");
13142 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
13143 // debug statements here
13145 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
13147 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
13148 if(!isWasmInitialized) {
13149 throw new Error("initializeWasm() must be awaited first!");
13151 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
13152 return nativeResponseValue;
13154 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
13156 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
13157 if(!isWasmInitialized) {
13158 throw new Error("initializeWasm() must be awaited first!");
13160 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
13161 return nativeResponseValue;
13163 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
13165 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
13166 if(!isWasmInitialized) {
13167 throw new Error("initializeWasm() must be awaited first!");
13169 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
13170 return nativeResponseValue;
13172 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13174 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
13175 if(!isWasmInitialized) {
13176 throw new Error("initializeWasm() must be awaited first!");
13178 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
13179 return nativeResponseValue;
13181 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
13183 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
13184 if(!isWasmInitialized) {
13185 throw new Error("initializeWasm() must be awaited first!");
13187 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
13188 return nativeResponseValue;
13190 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
13192 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
13193 if(!isWasmInitialized) {
13194 throw new Error("initializeWasm() must be awaited first!");
13196 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
13197 // debug statements here
13199 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
13201 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13202 if(!isWasmInitialized) {
13203 throw new Error("initializeWasm() must be awaited first!");
13205 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13206 return nativeResponseValue;
13208 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13210 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13211 if(!isWasmInitialized) {
13212 throw new Error("initializeWasm() must be awaited first!");
13214 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13215 return nativeResponseValue;
13217 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
13219 export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
13220 if(!isWasmInitialized) {
13221 throw new Error("initializeWasm() must be awaited first!");
13223 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_ok(o);
13224 return nativeResponseValue;
13226 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
13228 export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
13229 if(!isWasmInitialized) {
13230 throw new Error("initializeWasm() must be awaited first!");
13232 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_err(e);
13233 return nativeResponseValue;
13235 // bool CResult_FundingLockedDecodeErrorZ_is_ok(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR o);
13237 export function CResult_FundingLockedDecodeErrorZ_is_ok(o: number): boolean {
13238 if(!isWasmInitialized) {
13239 throw new Error("initializeWasm() must be awaited first!");
13241 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_is_ok(o);
13242 return nativeResponseValue;
13244 // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
13246 export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
13247 if(!isWasmInitialized) {
13248 throw new Error("initializeWasm() must be awaited first!");
13250 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_free(_res);
13251 // debug statements here
13253 // uintptr_t CResult_FundingLockedDecodeErrorZ_clone_ptr(LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR arg);
13255 export function CResult_FundingLockedDecodeErrorZ_clone_ptr(arg: number): number {
13256 if(!isWasmInitialized) {
13257 throw new Error("initializeWasm() must be awaited first!");
13259 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone_ptr(arg);
13260 return nativeResponseValue;
13262 // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
13264 export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
13265 if(!isWasmInitialized) {
13266 throw new Error("initializeWasm() must be awaited first!");
13268 const nativeResponseValue = wasm.TS_CResult_FundingLockedDecodeErrorZ_clone(orig);
13269 return nativeResponseValue;
13271 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13273 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13274 if(!isWasmInitialized) {
13275 throw new Error("initializeWasm() must be awaited first!");
13277 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13278 return nativeResponseValue;
13280 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13282 export function CResult_InitDecodeErrorZ_err(e: number): number {
13283 if(!isWasmInitialized) {
13284 throw new Error("initializeWasm() must be awaited first!");
13286 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13287 return nativeResponseValue;
13289 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13291 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13292 if(!isWasmInitialized) {
13293 throw new Error("initializeWasm() must be awaited first!");
13295 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13296 return nativeResponseValue;
13298 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13300 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13301 if(!isWasmInitialized) {
13302 throw new Error("initializeWasm() must be awaited first!");
13304 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13305 // debug statements here
13307 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13309 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13310 if(!isWasmInitialized) {
13311 throw new Error("initializeWasm() must be awaited first!");
13313 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13314 return nativeResponseValue;
13316 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13318 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13319 if(!isWasmInitialized) {
13320 throw new Error("initializeWasm() must be awaited first!");
13322 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13323 return nativeResponseValue;
13325 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13327 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13328 if(!isWasmInitialized) {
13329 throw new Error("initializeWasm() must be awaited first!");
13331 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13332 return nativeResponseValue;
13334 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13336 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13337 if(!isWasmInitialized) {
13338 throw new Error("initializeWasm() must be awaited first!");
13340 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13341 return nativeResponseValue;
13343 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13345 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13346 if(!isWasmInitialized) {
13347 throw new Error("initializeWasm() must be awaited first!");
13349 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13350 return nativeResponseValue;
13352 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13354 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13355 if(!isWasmInitialized) {
13356 throw new Error("initializeWasm() must be awaited first!");
13358 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13359 // debug statements here
13361 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13363 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13364 if(!isWasmInitialized) {
13365 throw new Error("initializeWasm() must be awaited first!");
13367 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13368 return nativeResponseValue;
13370 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13372 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13373 if(!isWasmInitialized) {
13374 throw new Error("initializeWasm() must be awaited first!");
13376 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13377 return nativeResponseValue;
13379 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13381 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13382 if(!isWasmInitialized) {
13383 throw new Error("initializeWasm() must be awaited first!");
13385 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13386 return nativeResponseValue;
13388 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13390 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13391 if(!isWasmInitialized) {
13392 throw new Error("initializeWasm() must be awaited first!");
13394 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13395 return nativeResponseValue;
13397 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13399 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13400 if(!isWasmInitialized) {
13401 throw new Error("initializeWasm() must be awaited first!");
13403 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13404 return nativeResponseValue;
13406 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13408 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13409 if(!isWasmInitialized) {
13410 throw new Error("initializeWasm() must be awaited first!");
13412 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13413 // debug statements here
13415 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
13417 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
13418 if(!isWasmInitialized) {
13419 throw new Error("initializeWasm() must be awaited first!");
13421 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
13422 return nativeResponseValue;
13424 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
13426 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
13427 if(!isWasmInitialized) {
13428 throw new Error("initializeWasm() must be awaited first!");
13430 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
13431 return nativeResponseValue;
13433 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
13435 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
13436 if(!isWasmInitialized) {
13437 throw new Error("initializeWasm() must be awaited first!");
13439 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
13440 return nativeResponseValue;
13442 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
13444 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
13445 if(!isWasmInitialized) {
13446 throw new Error("initializeWasm() must be awaited first!");
13448 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
13449 return nativeResponseValue;
13451 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
13453 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
13454 if(!isWasmInitialized) {
13455 throw new Error("initializeWasm() must be awaited first!");
13457 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
13458 return nativeResponseValue;
13460 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
13462 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
13463 if(!isWasmInitialized) {
13464 throw new Error("initializeWasm() must be awaited first!");
13466 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
13467 // debug statements here
13469 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
13471 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
13472 if(!isWasmInitialized) {
13473 throw new Error("initializeWasm() must be awaited first!");
13475 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
13476 return nativeResponseValue;
13478 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
13480 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
13481 if(!isWasmInitialized) {
13482 throw new Error("initializeWasm() must be awaited first!");
13484 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
13485 return nativeResponseValue;
13487 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
13489 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
13490 if(!isWasmInitialized) {
13491 throw new Error("initializeWasm() must be awaited first!");
13493 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
13494 return nativeResponseValue;
13496 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13498 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
13499 if(!isWasmInitialized) {
13500 throw new Error("initializeWasm() must be awaited first!");
13502 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
13503 return nativeResponseValue;
13505 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
13507 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
13508 if(!isWasmInitialized) {
13509 throw new Error("initializeWasm() must be awaited first!");
13511 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
13512 return nativeResponseValue;
13514 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
13516 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
13517 if(!isWasmInitialized) {
13518 throw new Error("initializeWasm() must be awaited first!");
13520 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
13521 // debug statements here
13523 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
13525 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13526 if(!isWasmInitialized) {
13527 throw new Error("initializeWasm() must be awaited first!");
13529 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
13530 return nativeResponseValue;
13532 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
13534 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
13535 if(!isWasmInitialized) {
13536 throw new Error("initializeWasm() must be awaited first!");
13538 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
13539 return nativeResponseValue;
13541 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
13543 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
13544 if(!isWasmInitialized) {
13545 throw new Error("initializeWasm() must be awaited first!");
13547 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
13548 return nativeResponseValue;
13550 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13552 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
13553 if(!isWasmInitialized) {
13554 throw new Error("initializeWasm() must be awaited first!");
13556 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
13557 return nativeResponseValue;
13559 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
13561 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
13562 if(!isWasmInitialized) {
13563 throw new Error("initializeWasm() must be awaited first!");
13565 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
13566 return nativeResponseValue;
13568 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
13570 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
13571 if(!isWasmInitialized) {
13572 throw new Error("initializeWasm() must be awaited first!");
13574 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
13575 // debug statements here
13577 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
13579 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13580 if(!isWasmInitialized) {
13581 throw new Error("initializeWasm() must be awaited first!");
13583 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
13584 return nativeResponseValue;
13586 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
13588 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
13589 if(!isWasmInitialized) {
13590 throw new Error("initializeWasm() must be awaited first!");
13592 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
13593 return nativeResponseValue;
13595 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
13597 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
13598 if(!isWasmInitialized) {
13599 throw new Error("initializeWasm() must be awaited first!");
13601 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
13602 return nativeResponseValue;
13604 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
13606 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
13607 if(!isWasmInitialized) {
13608 throw new Error("initializeWasm() must be awaited first!");
13610 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
13611 return nativeResponseValue;
13613 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
13615 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
13616 if(!isWasmInitialized) {
13617 throw new Error("initializeWasm() must be awaited first!");
13619 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
13620 return nativeResponseValue;
13622 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
13624 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
13625 if(!isWasmInitialized) {
13626 throw new Error("initializeWasm() must be awaited first!");
13628 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
13629 // debug statements here
13631 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
13633 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
13634 if(!isWasmInitialized) {
13635 throw new Error("initializeWasm() must be awaited first!");
13637 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
13638 return nativeResponseValue;
13640 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
13642 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
13643 if(!isWasmInitialized) {
13644 throw new Error("initializeWasm() must be awaited first!");
13646 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
13647 return nativeResponseValue;
13649 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
13651 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
13652 if(!isWasmInitialized) {
13653 throw new Error("initializeWasm() must be awaited first!");
13655 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
13656 return nativeResponseValue;
13658 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13660 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
13661 if(!isWasmInitialized) {
13662 throw new Error("initializeWasm() must be awaited first!");
13664 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
13665 return nativeResponseValue;
13667 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
13669 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
13670 if(!isWasmInitialized) {
13671 throw new Error("initializeWasm() must be awaited first!");
13673 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
13674 return nativeResponseValue;
13676 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
13678 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
13679 if(!isWasmInitialized) {
13680 throw new Error("initializeWasm() must be awaited first!");
13682 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
13683 // debug statements here
13685 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
13687 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13688 if(!isWasmInitialized) {
13689 throw new Error("initializeWasm() must be awaited first!");
13691 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
13692 return nativeResponseValue;
13694 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
13696 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
13697 if(!isWasmInitialized) {
13698 throw new Error("initializeWasm() must be awaited first!");
13700 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
13701 return nativeResponseValue;
13703 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
13705 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
13706 if(!isWasmInitialized) {
13707 throw new Error("initializeWasm() must be awaited first!");
13709 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
13710 return nativeResponseValue;
13712 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13714 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
13715 if(!isWasmInitialized) {
13716 throw new Error("initializeWasm() must be awaited first!");
13718 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
13719 return nativeResponseValue;
13721 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
13723 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
13724 if(!isWasmInitialized) {
13725 throw new Error("initializeWasm() must be awaited first!");
13727 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
13728 return nativeResponseValue;
13730 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
13732 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
13733 if(!isWasmInitialized) {
13734 throw new Error("initializeWasm() must be awaited first!");
13736 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
13737 // debug statements here
13739 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
13741 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13742 if(!isWasmInitialized) {
13743 throw new Error("initializeWasm() must be awaited first!");
13745 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
13746 return nativeResponseValue;
13748 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
13750 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
13751 if(!isWasmInitialized) {
13752 throw new Error("initializeWasm() must be awaited first!");
13754 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
13755 return nativeResponseValue;
13757 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
13759 export function CResult_PingDecodeErrorZ_ok(o: number): number {
13760 if(!isWasmInitialized) {
13761 throw new Error("initializeWasm() must be awaited first!");
13763 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
13764 return nativeResponseValue;
13766 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
13768 export function CResult_PingDecodeErrorZ_err(e: number): number {
13769 if(!isWasmInitialized) {
13770 throw new Error("initializeWasm() must be awaited first!");
13772 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
13773 return nativeResponseValue;
13775 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
13777 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
13778 if(!isWasmInitialized) {
13779 throw new Error("initializeWasm() must be awaited first!");
13781 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
13782 return nativeResponseValue;
13784 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
13786 export function CResult_PingDecodeErrorZ_free(_res: number): void {
13787 if(!isWasmInitialized) {
13788 throw new Error("initializeWasm() must be awaited first!");
13790 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
13791 // debug statements here
13793 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
13795 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
13796 if(!isWasmInitialized) {
13797 throw new Error("initializeWasm() must be awaited first!");
13799 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
13800 return nativeResponseValue;
13802 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
13804 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
13805 if(!isWasmInitialized) {
13806 throw new Error("initializeWasm() must be awaited first!");
13808 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
13809 return nativeResponseValue;
13811 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
13813 export function CResult_PongDecodeErrorZ_ok(o: number): number {
13814 if(!isWasmInitialized) {
13815 throw new Error("initializeWasm() must be awaited first!");
13817 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
13818 return nativeResponseValue;
13820 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
13822 export function CResult_PongDecodeErrorZ_err(e: number): number {
13823 if(!isWasmInitialized) {
13824 throw new Error("initializeWasm() must be awaited first!");
13826 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
13827 return nativeResponseValue;
13829 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
13831 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
13832 if(!isWasmInitialized) {
13833 throw new Error("initializeWasm() must be awaited first!");
13835 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
13836 return nativeResponseValue;
13838 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
13840 export function CResult_PongDecodeErrorZ_free(_res: number): void {
13841 if(!isWasmInitialized) {
13842 throw new Error("initializeWasm() must be awaited first!");
13844 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
13845 // debug statements here
13847 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
13849 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
13850 if(!isWasmInitialized) {
13851 throw new Error("initializeWasm() must be awaited first!");
13853 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
13854 return nativeResponseValue;
13856 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
13858 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
13859 if(!isWasmInitialized) {
13860 throw new Error("initializeWasm() must be awaited first!");
13862 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
13863 return nativeResponseValue;
13865 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
13867 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
13868 if(!isWasmInitialized) {
13869 throw new Error("initializeWasm() must be awaited first!");
13871 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
13872 return nativeResponseValue;
13874 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13876 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
13877 if(!isWasmInitialized) {
13878 throw new Error("initializeWasm() must be awaited first!");
13880 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
13881 return nativeResponseValue;
13883 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
13885 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
13886 if(!isWasmInitialized) {
13887 throw new Error("initializeWasm() must be awaited first!");
13889 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
13890 return nativeResponseValue;
13892 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
13894 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
13895 if(!isWasmInitialized) {
13896 throw new Error("initializeWasm() must be awaited first!");
13898 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
13899 // debug statements here
13901 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
13903 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
13904 if(!isWasmInitialized) {
13905 throw new Error("initializeWasm() must be awaited first!");
13907 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
13908 return nativeResponseValue;
13910 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
13912 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
13913 if(!isWasmInitialized) {
13914 throw new Error("initializeWasm() must be awaited first!");
13916 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
13917 return nativeResponseValue;
13919 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
13921 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
13922 if(!isWasmInitialized) {
13923 throw new Error("initializeWasm() must be awaited first!");
13925 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
13926 return nativeResponseValue;
13928 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
13930 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
13931 if(!isWasmInitialized) {
13932 throw new Error("initializeWasm() must be awaited first!");
13934 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
13935 return nativeResponseValue;
13937 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
13939 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
13940 if(!isWasmInitialized) {
13941 throw new Error("initializeWasm() must be awaited first!");
13943 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
13944 return nativeResponseValue;
13946 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
13948 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
13949 if(!isWasmInitialized) {
13950 throw new Error("initializeWasm() must be awaited first!");
13952 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
13953 // debug statements here
13955 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
13957 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
13958 if(!isWasmInitialized) {
13959 throw new Error("initializeWasm() must be awaited first!");
13961 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
13962 return nativeResponseValue;
13964 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
13966 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
13967 if(!isWasmInitialized) {
13968 throw new Error("initializeWasm() must be awaited first!");
13970 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
13971 return nativeResponseValue;
13973 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
13975 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
13976 if(!isWasmInitialized) {
13977 throw new Error("initializeWasm() must be awaited first!");
13979 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
13980 return nativeResponseValue;
13982 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
13984 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
13985 if(!isWasmInitialized) {
13986 throw new Error("initializeWasm() must be awaited first!");
13988 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
13989 return nativeResponseValue;
13991 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
13993 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
13994 if(!isWasmInitialized) {
13995 throw new Error("initializeWasm() must be awaited first!");
13997 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
13998 return nativeResponseValue;
14000 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14002 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14003 if(!isWasmInitialized) {
14004 throw new Error("initializeWasm() must be awaited first!");
14006 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14007 // debug statements here
14009 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14011 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14012 if(!isWasmInitialized) {
14013 throw new Error("initializeWasm() must be awaited first!");
14015 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14016 return nativeResponseValue;
14018 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14020 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14021 if(!isWasmInitialized) {
14022 throw new Error("initializeWasm() must be awaited first!");
14024 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14025 return nativeResponseValue;
14027 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14029 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14030 if(!isWasmInitialized) {
14031 throw new Error("initializeWasm() must be awaited first!");
14033 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14034 return nativeResponseValue;
14036 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14038 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14039 if(!isWasmInitialized) {
14040 throw new Error("initializeWasm() must be awaited first!");
14042 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14043 return nativeResponseValue;
14045 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14047 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14048 if(!isWasmInitialized) {
14049 throw new Error("initializeWasm() must be awaited first!");
14051 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14052 return nativeResponseValue;
14054 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14056 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14057 if(!isWasmInitialized) {
14058 throw new Error("initializeWasm() must be awaited first!");
14060 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14061 // debug statements here
14063 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14065 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14066 if(!isWasmInitialized) {
14067 throw new Error("initializeWasm() must be awaited first!");
14069 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14070 return nativeResponseValue;
14072 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14074 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14075 if(!isWasmInitialized) {
14076 throw new Error("initializeWasm() must be awaited first!");
14078 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14079 return nativeResponseValue;
14081 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14083 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14084 if(!isWasmInitialized) {
14085 throw new Error("initializeWasm() must be awaited first!");
14087 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14088 return nativeResponseValue;
14090 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14092 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14093 if(!isWasmInitialized) {
14094 throw new Error("initializeWasm() must be awaited first!");
14096 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
14097 return nativeResponseValue;
14099 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14101 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14102 if(!isWasmInitialized) {
14103 throw new Error("initializeWasm() must be awaited first!");
14105 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14106 return nativeResponseValue;
14108 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14110 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14111 if(!isWasmInitialized) {
14112 throw new Error("initializeWasm() must be awaited first!");
14114 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14115 // debug statements here
14117 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
14119 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
14120 if(!isWasmInitialized) {
14121 throw new Error("initializeWasm() must be awaited first!");
14123 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
14124 return nativeResponseValue;
14126 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
14128 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
14129 if(!isWasmInitialized) {
14130 throw new Error("initializeWasm() must be awaited first!");
14132 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
14133 return nativeResponseValue;
14135 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
14137 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
14138 if(!isWasmInitialized) {
14139 throw new Error("initializeWasm() must be awaited first!");
14141 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
14142 return nativeResponseValue;
14144 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
14146 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
14147 if(!isWasmInitialized) {
14148 throw new Error("initializeWasm() must be awaited first!");
14150 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
14151 return nativeResponseValue;
14153 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
14155 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
14156 if(!isWasmInitialized) {
14157 throw new Error("initializeWasm() must be awaited first!");
14159 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
14160 return nativeResponseValue;
14162 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
14164 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
14165 if(!isWasmInitialized) {
14166 throw new Error("initializeWasm() must be awaited first!");
14168 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
14169 // debug statements here
14171 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
14173 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
14174 if(!isWasmInitialized) {
14175 throw new Error("initializeWasm() must be awaited first!");
14177 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
14178 return nativeResponseValue;
14180 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
14182 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
14183 if(!isWasmInitialized) {
14184 throw new Error("initializeWasm() must be awaited first!");
14186 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
14187 return nativeResponseValue;
14189 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
14191 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
14192 if(!isWasmInitialized) {
14193 throw new Error("initializeWasm() must be awaited first!");
14195 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
14196 return nativeResponseValue;
14198 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14200 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
14201 if(!isWasmInitialized) {
14202 throw new Error("initializeWasm() must be awaited first!");
14204 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
14205 return nativeResponseValue;
14207 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14209 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14210 if(!isWasmInitialized) {
14211 throw new Error("initializeWasm() must be awaited first!");
14213 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14214 return nativeResponseValue;
14216 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14218 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14219 if(!isWasmInitialized) {
14220 throw new Error("initializeWasm() must be awaited first!");
14222 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14223 // debug statements here
14225 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14227 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14228 if(!isWasmInitialized) {
14229 throw new Error("initializeWasm() must be awaited first!");
14231 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14232 return nativeResponseValue;
14234 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14236 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14237 if(!isWasmInitialized) {
14238 throw new Error("initializeWasm() must be awaited first!");
14240 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14241 return nativeResponseValue;
14243 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14245 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14246 if(!isWasmInitialized) {
14247 throw new Error("initializeWasm() must be awaited first!");
14249 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14250 return nativeResponseValue;
14252 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14254 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14255 if(!isWasmInitialized) {
14256 throw new Error("initializeWasm() must be awaited first!");
14258 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14259 return nativeResponseValue;
14261 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14263 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14264 if(!isWasmInitialized) {
14265 throw new Error("initializeWasm() must be awaited first!");
14267 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14268 return nativeResponseValue;
14270 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14272 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14273 if(!isWasmInitialized) {
14274 throw new Error("initializeWasm() must be awaited first!");
14276 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14277 // debug statements here
14279 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14281 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14282 if(!isWasmInitialized) {
14283 throw new Error("initializeWasm() must be awaited first!");
14285 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14286 return nativeResponseValue;
14288 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14290 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14291 if(!isWasmInitialized) {
14292 throw new Error("initializeWasm() must be awaited first!");
14294 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14295 return nativeResponseValue;
14297 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14299 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14300 if(!isWasmInitialized) {
14301 throw new Error("initializeWasm() must be awaited first!");
14303 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14304 return nativeResponseValue;
14306 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14308 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14309 if(!isWasmInitialized) {
14310 throw new Error("initializeWasm() must be awaited first!");
14312 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14313 return nativeResponseValue;
14315 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14317 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14318 if(!isWasmInitialized) {
14319 throw new Error("initializeWasm() must be awaited first!");
14321 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14322 return nativeResponseValue;
14324 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14326 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14327 if(!isWasmInitialized) {
14328 throw new Error("initializeWasm() must be awaited first!");
14330 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14331 // debug statements here
14333 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14335 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14336 if(!isWasmInitialized) {
14337 throw new Error("initializeWasm() must be awaited first!");
14339 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14340 return nativeResponseValue;
14342 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14344 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14345 if(!isWasmInitialized) {
14346 throw new Error("initializeWasm() must be awaited first!");
14348 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14349 return nativeResponseValue;
14351 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14353 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14354 if(!isWasmInitialized) {
14355 throw new Error("initializeWasm() must be awaited first!");
14357 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14358 return nativeResponseValue;
14360 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14362 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14363 if(!isWasmInitialized) {
14364 throw new Error("initializeWasm() must be awaited first!");
14366 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14367 return nativeResponseValue;
14369 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14371 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14372 if(!isWasmInitialized) {
14373 throw new Error("initializeWasm() must be awaited first!");
14375 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14376 return nativeResponseValue;
14378 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14380 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14381 if(!isWasmInitialized) {
14382 throw new Error("initializeWasm() must be awaited first!");
14384 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14385 // debug statements here
14387 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14389 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14390 if(!isWasmInitialized) {
14391 throw new Error("initializeWasm() must be awaited first!");
14393 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14394 return nativeResponseValue;
14396 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14398 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14399 if(!isWasmInitialized) {
14400 throw new Error("initializeWasm() must be awaited first!");
14402 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14403 return nativeResponseValue;
14405 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14407 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14408 if(!isWasmInitialized) {
14409 throw new Error("initializeWasm() must be awaited first!");
14411 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14412 return nativeResponseValue;
14414 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14416 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
14417 if(!isWasmInitialized) {
14418 throw new Error("initializeWasm() must be awaited first!");
14420 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
14421 return nativeResponseValue;
14423 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
14425 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14426 if(!isWasmInitialized) {
14427 throw new Error("initializeWasm() must be awaited first!");
14429 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
14430 return nativeResponseValue;
14432 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
14434 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
14435 if(!isWasmInitialized) {
14436 throw new Error("initializeWasm() must be awaited first!");
14438 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
14439 // debug statements here
14441 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14443 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14444 if(!isWasmInitialized) {
14445 throw new Error("initializeWasm() must be awaited first!");
14447 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
14448 return nativeResponseValue;
14450 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14452 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
14453 if(!isWasmInitialized) {
14454 throw new Error("initializeWasm() must be awaited first!");
14456 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
14457 return nativeResponseValue;
14459 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
14461 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
14462 if(!isWasmInitialized) {
14463 throw new Error("initializeWasm() must be awaited first!");
14465 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
14466 return nativeResponseValue;
14468 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14470 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
14471 if(!isWasmInitialized) {
14472 throw new Error("initializeWasm() must be awaited first!");
14474 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
14475 return nativeResponseValue;
14477 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
14479 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14480 if(!isWasmInitialized) {
14481 throw new Error("initializeWasm() must be awaited first!");
14483 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
14484 return nativeResponseValue;
14486 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
14488 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
14489 if(!isWasmInitialized) {
14490 throw new Error("initializeWasm() must be awaited first!");
14492 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
14493 // debug statements here
14495 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14497 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14498 if(!isWasmInitialized) {
14499 throw new Error("initializeWasm() must be awaited first!");
14501 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
14502 return nativeResponseValue;
14504 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14506 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
14507 if(!isWasmInitialized) {
14508 throw new Error("initializeWasm() must be awaited first!");
14510 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
14511 return nativeResponseValue;
14513 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
14515 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
14516 if(!isWasmInitialized) {
14517 throw new Error("initializeWasm() must be awaited first!");
14519 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
14520 return nativeResponseValue;
14522 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
14524 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
14525 if(!isWasmInitialized) {
14526 throw new Error("initializeWasm() must be awaited first!");
14528 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
14529 return nativeResponseValue;
14531 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
14533 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
14534 if(!isWasmInitialized) {
14535 throw new Error("initializeWasm() must be awaited first!");
14537 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
14538 return nativeResponseValue;
14540 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
14542 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
14543 if(!isWasmInitialized) {
14544 throw new Error("initializeWasm() must be awaited first!");
14546 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
14547 // debug statements here
14549 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
14551 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
14552 if(!isWasmInitialized) {
14553 throw new Error("initializeWasm() must be awaited first!");
14555 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
14556 return nativeResponseValue;
14558 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
14560 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
14561 if(!isWasmInitialized) {
14562 throw new Error("initializeWasm() must be awaited first!");
14564 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
14565 return nativeResponseValue;
14567 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
14569 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
14570 if(!isWasmInitialized) {
14571 throw new Error("initializeWasm() must be awaited first!");
14573 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
14574 return nativeResponseValue;
14576 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
14578 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
14579 if(!isWasmInitialized) {
14580 throw new Error("initializeWasm() must be awaited first!");
14582 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
14583 return nativeResponseValue;
14585 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
14587 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
14588 if(!isWasmInitialized) {
14589 throw new Error("initializeWasm() must be awaited first!");
14591 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
14592 return nativeResponseValue;
14594 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
14596 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
14597 if(!isWasmInitialized) {
14598 throw new Error("initializeWasm() must be awaited first!");
14600 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
14601 // debug statements here
14603 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
14605 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
14606 if(!isWasmInitialized) {
14607 throw new Error("initializeWasm() must be awaited first!");
14609 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
14610 return nativeResponseValue;
14612 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
14614 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
14615 if(!isWasmInitialized) {
14616 throw new Error("initializeWasm() must be awaited first!");
14618 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
14619 return nativeResponseValue;
14621 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
14623 export function COption_FilterZ_some(o: number): number {
14624 if(!isWasmInitialized) {
14625 throw new Error("initializeWasm() must be awaited first!");
14627 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
14628 return nativeResponseValue;
14630 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
14632 export function COption_FilterZ_none(): number {
14633 if(!isWasmInitialized) {
14634 throw new Error("initializeWasm() must be awaited first!");
14636 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
14637 return nativeResponseValue;
14639 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
14641 export function COption_FilterZ_free(_res: number): void {
14642 if(!isWasmInitialized) {
14643 throw new Error("initializeWasm() must be awaited first!");
14645 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
14646 // debug statements here
14648 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
14650 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
14651 if(!isWasmInitialized) {
14652 throw new Error("initializeWasm() must be awaited first!");
14654 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
14655 return nativeResponseValue;
14657 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
14659 export function CResult_LockedChannelMonitorNoneZ_err(): number {
14660 if(!isWasmInitialized) {
14661 throw new Error("initializeWasm() must be awaited first!");
14663 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
14664 return nativeResponseValue;
14666 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
14668 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
14669 if(!isWasmInitialized) {
14670 throw new Error("initializeWasm() must be awaited first!");
14672 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
14673 return nativeResponseValue;
14675 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
14677 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
14678 if(!isWasmInitialized) {
14679 throw new Error("initializeWasm() must be awaited first!");
14681 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
14682 // debug statements here
14684 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
14686 export function CVec_OutPointZ_free(_res: number): void {
14687 if(!isWasmInitialized) {
14688 throw new Error("initializeWasm() must be awaited first!");
14690 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
14691 // debug statements here
14693 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
14695 export function PaymentPurpose_free(this_ptr: number): void {
14696 if(!isWasmInitialized) {
14697 throw new Error("initializeWasm() must be awaited first!");
14699 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
14700 // debug statements here
14702 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
14704 export function PaymentPurpose_clone_ptr(arg: number): number {
14705 if(!isWasmInitialized) {
14706 throw new Error("initializeWasm() must be awaited first!");
14708 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
14709 return nativeResponseValue;
14711 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
14713 export function PaymentPurpose_clone(orig: number): number {
14714 if(!isWasmInitialized) {
14715 throw new Error("initializeWasm() must be awaited first!");
14717 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
14718 return nativeResponseValue;
14720 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
14722 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
14723 if(!isWasmInitialized) {
14724 throw new Error("initializeWasm() must be awaited first!");
14726 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
14727 return nativeResponseValue;
14729 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
14731 export function PaymentPurpose_spontaneous_payment(a: number): number {
14732 if(!isWasmInitialized) {
14733 throw new Error("initializeWasm() must be awaited first!");
14735 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
14736 return nativeResponseValue;
14738 // void ClosureReason_free(struct LDKClosureReason this_ptr);
14740 export function ClosureReason_free(this_ptr: number): void {
14741 if(!isWasmInitialized) {
14742 throw new Error("initializeWasm() must be awaited first!");
14744 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
14745 // debug statements here
14747 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
14749 export function ClosureReason_clone_ptr(arg: number): number {
14750 if(!isWasmInitialized) {
14751 throw new Error("initializeWasm() must be awaited first!");
14753 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
14754 return nativeResponseValue;
14756 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
14758 export function ClosureReason_clone(orig: number): number {
14759 if(!isWasmInitialized) {
14760 throw new Error("initializeWasm() must be awaited first!");
14762 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
14763 return nativeResponseValue;
14765 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
14767 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
14768 if(!isWasmInitialized) {
14769 throw new Error("initializeWasm() must be awaited first!");
14771 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
14772 return nativeResponseValue;
14774 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
14776 export function ClosureReason_holder_force_closed(): number {
14777 if(!isWasmInitialized) {
14778 throw new Error("initializeWasm() must be awaited first!");
14780 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
14781 return nativeResponseValue;
14783 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
14785 export function ClosureReason_cooperative_closure(): number {
14786 if(!isWasmInitialized) {
14787 throw new Error("initializeWasm() must be awaited first!");
14789 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
14790 return nativeResponseValue;
14792 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
14794 export function ClosureReason_commitment_tx_confirmed(): number {
14795 if(!isWasmInitialized) {
14796 throw new Error("initializeWasm() must be awaited first!");
14798 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
14799 return nativeResponseValue;
14801 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
14803 export function ClosureReason_funding_timed_out(): number {
14804 if(!isWasmInitialized) {
14805 throw new Error("initializeWasm() must be awaited first!");
14807 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
14808 return nativeResponseValue;
14810 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
14812 export function ClosureReason_processing_error(err: number): number {
14813 if(!isWasmInitialized) {
14814 throw new Error("initializeWasm() must be awaited first!");
14816 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
14817 return nativeResponseValue;
14819 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
14821 export function ClosureReason_disconnected_peer(): number {
14822 if(!isWasmInitialized) {
14823 throw new Error("initializeWasm() must be awaited first!");
14825 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
14826 return nativeResponseValue;
14828 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
14830 export function ClosureReason_outdated_channel_manager(): number {
14831 if(!isWasmInitialized) {
14832 throw new Error("initializeWasm() must be awaited first!");
14834 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
14835 return nativeResponseValue;
14837 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
14839 export function ClosureReason_write(obj: number): number {
14840 if(!isWasmInitialized) {
14841 throw new Error("initializeWasm() must be awaited first!");
14843 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
14844 return nativeResponseValue;
14846 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
14848 export function ClosureReason_read(ser: number): number {
14849 if(!isWasmInitialized) {
14850 throw new Error("initializeWasm() must be awaited first!");
14852 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
14853 return nativeResponseValue;
14855 // void Event_free(struct LDKEvent this_ptr);
14857 export function Event_free(this_ptr: number): void {
14858 if(!isWasmInitialized) {
14859 throw new Error("initializeWasm() must be awaited first!");
14861 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
14862 // debug statements here
14864 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
14866 export function Event_clone_ptr(arg: number): number {
14867 if(!isWasmInitialized) {
14868 throw new Error("initializeWasm() must be awaited first!");
14870 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
14871 return nativeResponseValue;
14873 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
14875 export function Event_clone(orig: number): number {
14876 if(!isWasmInitialized) {
14877 throw new Error("initializeWasm() must be awaited first!");
14879 const nativeResponseValue = wasm.TS_Event_clone(orig);
14880 return nativeResponseValue;
14882 // struct LDKEvent Event_funding_generation_ready(struct LDKThirtyTwoBytes temporary_channel_id, uint64_t channel_value_satoshis, struct LDKCVec_u8Z output_script, uint64_t user_channel_id);
14884 export function Event_funding_generation_ready(temporary_channel_id: number, channel_value_satoshis: bigint, output_script: number, user_channel_id: bigint): number {
14885 if(!isWasmInitialized) {
14886 throw new Error("initializeWasm() must be awaited first!");
14888 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, channel_value_satoshis, output_script, user_channel_id);
14889 return nativeResponseValue;
14891 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amt, struct LDKPaymentPurpose purpose);
14893 export function Event_payment_received(payment_hash: number, amt: bigint, purpose: number): number {
14894 if(!isWasmInitialized) {
14895 throw new Error("initializeWasm() must be awaited first!");
14897 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amt, purpose);
14898 return nativeResponseValue;
14900 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
14902 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
14903 if(!isWasmInitialized) {
14904 throw new Error("initializeWasm() must be awaited first!");
14906 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
14907 return nativeResponseValue;
14909 // 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);
14911 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 {
14912 if(!isWasmInitialized) {
14913 throw new Error("initializeWasm() must be awaited first!");
14915 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);
14916 return nativeResponseValue;
14918 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
14920 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
14921 if(!isWasmInitialized) {
14922 throw new Error("initializeWasm() must be awaited first!");
14924 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
14925 return nativeResponseValue;
14927 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
14929 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
14930 if(!isWasmInitialized) {
14931 throw new Error("initializeWasm() must be awaited first!");
14933 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
14934 return nativeResponseValue;
14936 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
14938 export function Event_spendable_outputs(outputs: number): number {
14939 if(!isWasmInitialized) {
14940 throw new Error("initializeWasm() must be awaited first!");
14942 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
14943 return nativeResponseValue;
14945 // struct LDKEvent Event_payment_forwarded(struct LDKCOption_u64Z fee_earned_msat, bool claim_from_onchain_tx);
14947 export function Event_payment_forwarded(fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
14948 if(!isWasmInitialized) {
14949 throw new Error("initializeWasm() must be awaited first!");
14951 const nativeResponseValue = wasm.TS_Event_payment_forwarded(fee_earned_msat, claim_from_onchain_tx);
14952 return nativeResponseValue;
14954 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
14956 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
14957 if(!isWasmInitialized) {
14958 throw new Error("initializeWasm() must be awaited first!");
14960 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
14961 return nativeResponseValue;
14963 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
14965 export function Event_discard_funding(channel_id: number, transaction: number): number {
14966 if(!isWasmInitialized) {
14967 throw new Error("initializeWasm() must be awaited first!");
14969 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
14970 return nativeResponseValue;
14972 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
14974 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
14975 if(!isWasmInitialized) {
14976 throw new Error("initializeWasm() must be awaited first!");
14978 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
14979 return nativeResponseValue;
14981 // 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);
14983 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
14984 if(!isWasmInitialized) {
14985 throw new Error("initializeWasm() must be awaited first!");
14987 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
14988 return nativeResponseValue;
14990 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
14992 export function Event_write(obj: number): number {
14993 if(!isWasmInitialized) {
14994 throw new Error("initializeWasm() must be awaited first!");
14996 const nativeResponseValue = wasm.TS_Event_write(obj);
14997 return nativeResponseValue;
14999 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
15001 export function Event_read(ser: number): number {
15002 if(!isWasmInitialized) {
15003 throw new Error("initializeWasm() must be awaited first!");
15005 const nativeResponseValue = wasm.TS_Event_read(ser);
15006 return nativeResponseValue;
15008 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
15010 export function MessageSendEvent_free(this_ptr: number): void {
15011 if(!isWasmInitialized) {
15012 throw new Error("initializeWasm() must be awaited first!");
15014 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
15015 // debug statements here
15017 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
15019 export function MessageSendEvent_clone_ptr(arg: number): number {
15020 if(!isWasmInitialized) {
15021 throw new Error("initializeWasm() must be awaited first!");
15023 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
15024 return nativeResponseValue;
15026 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
15028 export function MessageSendEvent_clone(orig: number): number {
15029 if(!isWasmInitialized) {
15030 throw new Error("initializeWasm() must be awaited first!");
15032 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
15033 return nativeResponseValue;
15035 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
15037 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
15038 if(!isWasmInitialized) {
15039 throw new Error("initializeWasm() must be awaited first!");
15041 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
15042 return nativeResponseValue;
15044 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
15046 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
15047 if(!isWasmInitialized) {
15048 throw new Error("initializeWasm() must be awaited first!");
15050 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
15051 return nativeResponseValue;
15053 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
15055 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
15056 if(!isWasmInitialized) {
15057 throw new Error("initializeWasm() must be awaited first!");
15059 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
15060 return nativeResponseValue;
15062 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
15064 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
15065 if(!isWasmInitialized) {
15066 throw new Error("initializeWasm() must be awaited first!");
15068 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
15069 return nativeResponseValue;
15071 // struct LDKMessageSendEvent MessageSendEvent_send_funding_locked(struct LDKPublicKey node_id, struct LDKFundingLocked msg);
15073 export function MessageSendEvent_send_funding_locked(node_id: number, msg: number): number {
15074 if(!isWasmInitialized) {
15075 throw new Error("initializeWasm() must be awaited first!");
15077 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_locked(node_id, msg);
15078 return nativeResponseValue;
15080 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
15082 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
15083 if(!isWasmInitialized) {
15084 throw new Error("initializeWasm() must be awaited first!");
15086 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
15087 return nativeResponseValue;
15089 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
15091 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
15092 if(!isWasmInitialized) {
15093 throw new Error("initializeWasm() must be awaited first!");
15095 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
15096 return nativeResponseValue;
15098 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
15100 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
15101 if(!isWasmInitialized) {
15102 throw new Error("initializeWasm() must be awaited first!");
15104 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
15105 return nativeResponseValue;
15107 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
15109 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
15110 if(!isWasmInitialized) {
15111 throw new Error("initializeWasm() must be awaited first!");
15113 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
15114 return nativeResponseValue;
15116 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
15118 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
15119 if(!isWasmInitialized) {
15120 throw new Error("initializeWasm() must be awaited first!");
15122 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
15123 return nativeResponseValue;
15125 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
15127 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
15128 if(!isWasmInitialized) {
15129 throw new Error("initializeWasm() must be awaited first!");
15131 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
15132 return nativeResponseValue;
15134 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
15136 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
15137 if(!isWasmInitialized) {
15138 throw new Error("initializeWasm() must be awaited first!");
15140 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
15141 return nativeResponseValue;
15143 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
15145 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
15146 if(!isWasmInitialized) {
15147 throw new Error("initializeWasm() must be awaited first!");
15149 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
15150 return nativeResponseValue;
15152 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
15154 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
15155 if(!isWasmInitialized) {
15156 throw new Error("initializeWasm() must be awaited first!");
15158 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
15159 return nativeResponseValue;
15161 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
15163 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
15164 if(!isWasmInitialized) {
15165 throw new Error("initializeWasm() must be awaited first!");
15167 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
15168 return nativeResponseValue;
15170 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
15172 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
15173 if(!isWasmInitialized) {
15174 throw new Error("initializeWasm() must be awaited first!");
15176 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
15177 return nativeResponseValue;
15179 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
15181 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
15182 if(!isWasmInitialized) {
15183 throw new Error("initializeWasm() must be awaited first!");
15185 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
15186 return nativeResponseValue;
15188 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
15190 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
15191 if(!isWasmInitialized) {
15192 throw new Error("initializeWasm() must be awaited first!");
15194 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
15195 return nativeResponseValue;
15197 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
15199 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
15200 if(!isWasmInitialized) {
15201 throw new Error("initializeWasm() must be awaited first!");
15203 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
15204 return nativeResponseValue;
15206 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
15208 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
15209 if(!isWasmInitialized) {
15210 throw new Error("initializeWasm() must be awaited first!");
15212 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
15213 return nativeResponseValue;
15215 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15217 export function MessageSendEventsProvider_free(this_ptr: number): void {
15218 if(!isWasmInitialized) {
15219 throw new Error("initializeWasm() must be awaited first!");
15221 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15222 // debug statements here
15224 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15226 export function EventsProvider_free(this_ptr: number): void {
15227 if(!isWasmInitialized) {
15228 throw new Error("initializeWasm() must be awaited first!");
15230 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15231 // debug statements here
15233 // void EventHandler_free(struct LDKEventHandler this_ptr);
15235 export function EventHandler_free(this_ptr: number): void {
15236 if(!isWasmInitialized) {
15237 throw new Error("initializeWasm() must be awaited first!");
15239 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15240 // debug statements here
15242 // void APIError_free(struct LDKAPIError this_ptr);
15244 export function APIError_free(this_ptr: number): void {
15245 if(!isWasmInitialized) {
15246 throw new Error("initializeWasm() must be awaited first!");
15248 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15249 // debug statements here
15251 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15253 export function APIError_clone_ptr(arg: number): number {
15254 if(!isWasmInitialized) {
15255 throw new Error("initializeWasm() must be awaited first!");
15257 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15258 return nativeResponseValue;
15260 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15262 export function APIError_clone(orig: number): number {
15263 if(!isWasmInitialized) {
15264 throw new Error("initializeWasm() must be awaited first!");
15266 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15267 return nativeResponseValue;
15269 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15271 export function APIError_apimisuse_error(err: number): number {
15272 if(!isWasmInitialized) {
15273 throw new Error("initializeWasm() must be awaited first!");
15275 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15276 return nativeResponseValue;
15278 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15280 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15281 if(!isWasmInitialized) {
15282 throw new Error("initializeWasm() must be awaited first!");
15284 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15285 return nativeResponseValue;
15287 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15289 export function APIError_route_error(err: number): number {
15290 if(!isWasmInitialized) {
15291 throw new Error("initializeWasm() must be awaited first!");
15293 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15294 return nativeResponseValue;
15296 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15298 export function APIError_channel_unavailable(err: number): number {
15299 if(!isWasmInitialized) {
15300 throw new Error("initializeWasm() must be awaited first!");
15302 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15303 return nativeResponseValue;
15305 // struct LDKAPIError APIError_monitor_update_failed(void);
15307 export function APIError_monitor_update_failed(): number {
15308 if(!isWasmInitialized) {
15309 throw new Error("initializeWasm() must be awaited first!");
15311 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15312 return nativeResponseValue;
15314 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15316 export function APIError_incompatible_shutdown_script(script: number): number {
15317 if(!isWasmInitialized) {
15318 throw new Error("initializeWasm() must be awaited first!");
15320 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15321 return nativeResponseValue;
15323 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15325 export function sign(msg: number, sk: number): number {
15326 if(!isWasmInitialized) {
15327 throw new Error("initializeWasm() must be awaited first!");
15329 const nativeResponseValue = wasm.TS_sign(msg, sk);
15330 return nativeResponseValue;
15332 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15334 export function recover_pk(msg: number, sig: number): number {
15335 if(!isWasmInitialized) {
15336 throw new Error("initializeWasm() must be awaited first!");
15338 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15339 return nativeResponseValue;
15341 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15343 export function verify(msg: number, sig: number, pk: number): boolean {
15344 if(!isWasmInitialized) {
15345 throw new Error("initializeWasm() must be awaited first!");
15347 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15348 return nativeResponseValue;
15350 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
15352 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
15353 if(!isWasmInitialized) {
15354 throw new Error("initializeWasm() must be awaited first!");
15356 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
15357 return nativeResponseValue;
15359 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
15361 export function Level_clone(orig: number): Level {
15362 if(!isWasmInitialized) {
15363 throw new Error("initializeWasm() must be awaited first!");
15365 const nativeResponseValue = wasm.TS_Level_clone(orig);
15366 return nativeResponseValue;
15368 // enum LDKLevel Level_gossip(void);
15370 export function Level_gossip(): Level {
15371 if(!isWasmInitialized) {
15372 throw new Error("initializeWasm() must be awaited first!");
15374 const nativeResponseValue = wasm.TS_Level_gossip();
15375 return nativeResponseValue;
15377 // enum LDKLevel Level_trace(void);
15379 export function Level_trace(): Level {
15380 if(!isWasmInitialized) {
15381 throw new Error("initializeWasm() must be awaited first!");
15383 const nativeResponseValue = wasm.TS_Level_trace();
15384 return nativeResponseValue;
15386 // enum LDKLevel Level_debug(void);
15388 export function Level_debug(): Level {
15389 if(!isWasmInitialized) {
15390 throw new Error("initializeWasm() must be awaited first!");
15392 const nativeResponseValue = wasm.TS_Level_debug();
15393 return nativeResponseValue;
15395 // enum LDKLevel Level_info(void);
15397 export function Level_info(): Level {
15398 if(!isWasmInitialized) {
15399 throw new Error("initializeWasm() must be awaited first!");
15401 const nativeResponseValue = wasm.TS_Level_info();
15402 return nativeResponseValue;
15404 // enum LDKLevel Level_warn(void);
15406 export function Level_warn(): Level {
15407 if(!isWasmInitialized) {
15408 throw new Error("initializeWasm() must be awaited first!");
15410 const nativeResponseValue = wasm.TS_Level_warn();
15411 return nativeResponseValue;
15413 // enum LDKLevel Level_error(void);
15415 export function Level_error(): Level {
15416 if(!isWasmInitialized) {
15417 throw new Error("initializeWasm() must be awaited first!");
15419 const nativeResponseValue = wasm.TS_Level_error();
15420 return nativeResponseValue;
15422 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
15424 export function Level_eq(a: number, b: number): boolean {
15425 if(!isWasmInitialized) {
15426 throw new Error("initializeWasm() must be awaited first!");
15428 const nativeResponseValue = wasm.TS_Level_eq(a, b);
15429 return nativeResponseValue;
15431 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
15433 export function Level_hash(o: number): bigint {
15434 if(!isWasmInitialized) {
15435 throw new Error("initializeWasm() must be awaited first!");
15437 const nativeResponseValue = wasm.TS_Level_hash(o);
15438 return nativeResponseValue;
15440 // MUST_USE_RES enum LDKLevel Level_max(void);
15442 export function Level_max(): Level {
15443 if(!isWasmInitialized) {
15444 throw new Error("initializeWasm() must be awaited first!");
15446 const nativeResponseValue = wasm.TS_Level_max();
15447 return nativeResponseValue;
15449 // void Record_free(struct LDKRecord this_obj);
15451 export function Record_free(this_obj: number): void {
15452 if(!isWasmInitialized) {
15453 throw new Error("initializeWasm() must be awaited first!");
15455 const nativeResponseValue = wasm.TS_Record_free(this_obj);
15456 // debug statements here
15458 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
15460 export function Record_get_level(this_ptr: number): Level {
15461 if(!isWasmInitialized) {
15462 throw new Error("initializeWasm() must be awaited first!");
15464 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
15465 return nativeResponseValue;
15467 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
15469 export function Record_set_level(this_ptr: number, val: Level): void {
15470 if(!isWasmInitialized) {
15471 throw new Error("initializeWasm() must be awaited first!");
15473 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
15474 // debug statements here
15476 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
15478 export function Record_get_args(this_ptr: number): number {
15479 if(!isWasmInitialized) {
15480 throw new Error("initializeWasm() must be awaited first!");
15482 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
15483 return nativeResponseValue;
15485 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15487 export function Record_set_args(this_ptr: number, val: number): void {
15488 if(!isWasmInitialized) {
15489 throw new Error("initializeWasm() must be awaited first!");
15491 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
15492 // debug statements here
15494 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
15496 export function Record_get_module_path(this_ptr: number): number {
15497 if(!isWasmInitialized) {
15498 throw new Error("initializeWasm() must be awaited first!");
15500 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
15501 return nativeResponseValue;
15503 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15505 export function Record_set_module_path(this_ptr: number, val: number): void {
15506 if(!isWasmInitialized) {
15507 throw new Error("initializeWasm() must be awaited first!");
15509 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
15510 // debug statements here
15512 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
15514 export function Record_get_file(this_ptr: number): number {
15515 if(!isWasmInitialized) {
15516 throw new Error("initializeWasm() must be awaited first!");
15518 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
15519 return nativeResponseValue;
15521 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15523 export function Record_set_file(this_ptr: number, val: number): void {
15524 if(!isWasmInitialized) {
15525 throw new Error("initializeWasm() must be awaited first!");
15527 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
15528 // debug statements here
15530 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
15532 export function Record_get_line(this_ptr: number): number {
15533 if(!isWasmInitialized) {
15534 throw new Error("initializeWasm() must be awaited first!");
15536 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
15537 return nativeResponseValue;
15539 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
15541 export function Record_set_line(this_ptr: number, val: number): void {
15542 if(!isWasmInitialized) {
15543 throw new Error("initializeWasm() must be awaited first!");
15545 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
15546 // debug statements here
15548 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
15550 export function Record_clone_ptr(arg: number): number {
15551 if(!isWasmInitialized) {
15552 throw new Error("initializeWasm() must be awaited first!");
15554 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
15555 return nativeResponseValue;
15557 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
15559 export function Record_clone(orig: number): number {
15560 if(!isWasmInitialized) {
15561 throw new Error("initializeWasm() must be awaited first!");
15563 const nativeResponseValue = wasm.TS_Record_clone(orig);
15564 return nativeResponseValue;
15566 // void Logger_free(struct LDKLogger this_ptr);
15568 export function Logger_free(this_ptr: number): void {
15569 if(!isWasmInitialized) {
15570 throw new Error("initializeWasm() must be awaited first!");
15572 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
15573 // debug statements here
15575 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
15577 export function ChannelHandshakeConfig_free(this_obj: number): void {
15578 if(!isWasmInitialized) {
15579 throw new Error("initializeWasm() must be awaited first!");
15581 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
15582 // debug statements here
15584 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15586 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
15587 if(!isWasmInitialized) {
15588 throw new Error("initializeWasm() must be awaited first!");
15590 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
15591 return nativeResponseValue;
15593 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
15595 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
15596 if(!isWasmInitialized) {
15597 throw new Error("initializeWasm() must be awaited first!");
15599 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
15600 // debug statements here
15602 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15604 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
15605 if(!isWasmInitialized) {
15606 throw new Error("initializeWasm() must be awaited first!");
15608 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
15609 return nativeResponseValue;
15611 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
15613 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
15614 if(!isWasmInitialized) {
15615 throw new Error("initializeWasm() must be awaited first!");
15617 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
15618 // debug statements here
15620 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15622 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
15623 if(!isWasmInitialized) {
15624 throw new Error("initializeWasm() must be awaited first!");
15626 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
15627 return nativeResponseValue;
15629 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
15631 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
15632 if(!isWasmInitialized) {
15633 throw new Error("initializeWasm() must be awaited first!");
15635 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
15636 // debug statements here
15638 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15640 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
15641 if(!isWasmInitialized) {
15642 throw new Error("initializeWasm() must be awaited first!");
15644 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
15645 return nativeResponseValue;
15647 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
15649 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
15650 if(!isWasmInitialized) {
15651 throw new Error("initializeWasm() must be awaited first!");
15653 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
15654 // debug statements here
15656 // 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, bool negotiate_scid_privacy_arg);
15658 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint, negotiate_scid_privacy_arg: boolean): number {
15659 if(!isWasmInitialized) {
15660 throw new Error("initializeWasm() must be awaited first!");
15662 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, negotiate_scid_privacy_arg);
15663 return nativeResponseValue;
15665 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
15667 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
15668 if(!isWasmInitialized) {
15669 throw new Error("initializeWasm() must be awaited first!");
15671 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
15672 return nativeResponseValue;
15674 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
15676 export function ChannelHandshakeConfig_clone(orig: number): number {
15677 if(!isWasmInitialized) {
15678 throw new Error("initializeWasm() must be awaited first!");
15680 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
15681 return nativeResponseValue;
15683 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
15685 export function ChannelHandshakeConfig_default(): number {
15686 if(!isWasmInitialized) {
15687 throw new Error("initializeWasm() must be awaited first!");
15689 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
15690 return nativeResponseValue;
15692 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
15694 export function ChannelHandshakeLimits_free(this_obj: number): void {
15695 if(!isWasmInitialized) {
15696 throw new Error("initializeWasm() must be awaited first!");
15698 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
15699 // debug statements here
15701 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15703 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
15704 if(!isWasmInitialized) {
15705 throw new Error("initializeWasm() must be awaited first!");
15707 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
15708 return nativeResponseValue;
15710 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15712 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
15713 if(!isWasmInitialized) {
15714 throw new Error("initializeWasm() must be awaited first!");
15716 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
15717 // debug statements here
15719 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15721 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
15722 if(!isWasmInitialized) {
15723 throw new Error("initializeWasm() must be awaited first!");
15725 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
15726 return nativeResponseValue;
15728 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15730 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
15731 if(!isWasmInitialized) {
15732 throw new Error("initializeWasm() must be awaited first!");
15734 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
15735 // debug statements here
15737 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15739 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
15740 if(!isWasmInitialized) {
15741 throw new Error("initializeWasm() must be awaited first!");
15743 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
15744 return nativeResponseValue;
15746 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15748 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
15749 if(!isWasmInitialized) {
15750 throw new Error("initializeWasm() must be awaited first!");
15752 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
15753 // debug statements here
15755 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15757 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
15758 if(!isWasmInitialized) {
15759 throw new Error("initializeWasm() must be awaited first!");
15761 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
15762 return nativeResponseValue;
15764 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
15766 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
15767 if(!isWasmInitialized) {
15768 throw new Error("initializeWasm() must be awaited first!");
15770 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
15771 // debug statements here
15773 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15775 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
15776 if(!isWasmInitialized) {
15777 throw new Error("initializeWasm() must be awaited first!");
15779 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
15780 return nativeResponseValue;
15782 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
15784 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
15785 if(!isWasmInitialized) {
15786 throw new Error("initializeWasm() must be awaited first!");
15788 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
15789 // debug statements here
15791 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15793 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
15794 if(!isWasmInitialized) {
15795 throw new Error("initializeWasm() must be awaited first!");
15797 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
15798 return nativeResponseValue;
15800 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
15802 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
15803 if(!isWasmInitialized) {
15804 throw new Error("initializeWasm() must be awaited first!");
15806 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
15807 // debug statements here
15809 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15811 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
15812 if(!isWasmInitialized) {
15813 throw new Error("initializeWasm() must be awaited first!");
15815 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
15816 return nativeResponseValue;
15818 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
15820 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
15821 if(!isWasmInitialized) {
15822 throw new Error("initializeWasm() must be awaited first!");
15824 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
15825 // debug statements here
15827 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
15829 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
15830 if(!isWasmInitialized) {
15831 throw new Error("initializeWasm() must be awaited first!");
15833 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
15834 return nativeResponseValue;
15836 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
15838 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
15839 if(!isWasmInitialized) {
15840 throw new Error("initializeWasm() must be awaited first!");
15842 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
15843 // debug statements here
15845 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_new(uint64_t min_funding_satoshis_arg, uint64_t max_htlc_minimum_msat_arg, uint64_t min_max_htlc_value_in_flight_msat_arg, uint64_t max_channel_reserve_satoshis_arg, uint16_t min_max_accepted_htlcs_arg, uint32_t max_minimum_depth_arg, bool force_announced_channel_preference_arg, uint16_t their_to_self_delay_arg);
15847 export function ChannelHandshakeLimits_new(min_funding_satoshis_arg: bigint, max_htlc_minimum_msat_arg: bigint, min_max_htlc_value_in_flight_msat_arg: bigint, max_channel_reserve_satoshis_arg: bigint, min_max_accepted_htlcs_arg: number, max_minimum_depth_arg: number, force_announced_channel_preference_arg: boolean, their_to_self_delay_arg: number): number {
15848 if(!isWasmInitialized) {
15849 throw new Error("initializeWasm() must be awaited first!");
15851 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_new(min_funding_satoshis_arg, max_htlc_minimum_msat_arg, min_max_htlc_value_in_flight_msat_arg, max_channel_reserve_satoshis_arg, min_max_accepted_htlcs_arg, max_minimum_depth_arg, force_announced_channel_preference_arg, their_to_self_delay_arg);
15852 return nativeResponseValue;
15854 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
15856 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
15857 if(!isWasmInitialized) {
15858 throw new Error("initializeWasm() must be awaited first!");
15860 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
15861 return nativeResponseValue;
15863 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
15865 export function ChannelHandshakeLimits_clone(orig: number): number {
15866 if(!isWasmInitialized) {
15867 throw new Error("initializeWasm() must be awaited first!");
15869 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
15870 return nativeResponseValue;
15872 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
15874 export function ChannelHandshakeLimits_default(): number {
15875 if(!isWasmInitialized) {
15876 throw new Error("initializeWasm() must be awaited first!");
15878 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
15879 return nativeResponseValue;
15881 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
15883 export function ChannelConfig_free(this_obj: number): void {
15884 if(!isWasmInitialized) {
15885 throw new Error("initializeWasm() must be awaited first!");
15887 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
15888 // debug statements here
15890 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15892 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
15893 if(!isWasmInitialized) {
15894 throw new Error("initializeWasm() must be awaited first!");
15896 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
15897 return nativeResponseValue;
15899 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
15901 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
15902 if(!isWasmInitialized) {
15903 throw new Error("initializeWasm() must be awaited first!");
15905 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
15906 // debug statements here
15908 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15910 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
15911 if(!isWasmInitialized) {
15912 throw new Error("initializeWasm() must be awaited first!");
15914 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
15915 return nativeResponseValue;
15917 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
15919 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
15920 if(!isWasmInitialized) {
15921 throw new Error("initializeWasm() must be awaited first!");
15923 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
15924 // debug statements here
15926 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15928 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
15929 if(!isWasmInitialized) {
15930 throw new Error("initializeWasm() must be awaited first!");
15932 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
15933 return nativeResponseValue;
15935 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
15937 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
15938 if(!isWasmInitialized) {
15939 throw new Error("initializeWasm() must be awaited first!");
15941 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
15942 // debug statements here
15944 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15946 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
15947 if(!isWasmInitialized) {
15948 throw new Error("initializeWasm() must be awaited first!");
15950 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
15951 return nativeResponseValue;
15953 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
15955 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
15956 if(!isWasmInitialized) {
15957 throw new Error("initializeWasm() must be awaited first!");
15959 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
15960 // debug statements here
15962 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15964 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
15965 if(!isWasmInitialized) {
15966 throw new Error("initializeWasm() must be awaited first!");
15968 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
15969 return nativeResponseValue;
15971 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
15973 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
15974 if(!isWasmInitialized) {
15975 throw new Error("initializeWasm() must be awaited first!");
15977 const nativeResponseValue = wasm.TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
15978 // debug statements here
15980 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
15982 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
15983 if(!isWasmInitialized) {
15984 throw new Error("initializeWasm() must be awaited first!");
15986 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
15987 return nativeResponseValue;
15989 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
15991 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
15992 if(!isWasmInitialized) {
15993 throw new Error("initializeWasm() must be awaited first!");
15995 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
15996 // debug statements here
15998 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16000 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
16001 if(!isWasmInitialized) {
16002 throw new Error("initializeWasm() must be awaited first!");
16004 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
16005 return nativeResponseValue;
16007 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16009 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
16010 if(!isWasmInitialized) {
16011 throw new Error("initializeWasm() must be awaited first!");
16013 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
16014 // debug statements here
16016 // 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);
16018 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 {
16019 if(!isWasmInitialized) {
16020 throw new Error("initializeWasm() must be awaited first!");
16022 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);
16023 return nativeResponseValue;
16025 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
16027 export function ChannelConfig_clone_ptr(arg: number): number {
16028 if(!isWasmInitialized) {
16029 throw new Error("initializeWasm() must be awaited first!");
16031 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
16032 return nativeResponseValue;
16034 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
16036 export function ChannelConfig_clone(orig: number): number {
16037 if(!isWasmInitialized) {
16038 throw new Error("initializeWasm() must be awaited first!");
16040 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
16041 return nativeResponseValue;
16043 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
16045 export function ChannelConfig_default(): number {
16046 if(!isWasmInitialized) {
16047 throw new Error("initializeWasm() must be awaited first!");
16049 const nativeResponseValue = wasm.TS_ChannelConfig_default();
16050 return nativeResponseValue;
16052 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
16054 export function ChannelConfig_write(obj: number): number {
16055 if(!isWasmInitialized) {
16056 throw new Error("initializeWasm() must be awaited first!");
16058 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
16059 return nativeResponseValue;
16061 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
16063 export function ChannelConfig_read(ser: number): number {
16064 if(!isWasmInitialized) {
16065 throw new Error("initializeWasm() must be awaited first!");
16067 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
16068 return nativeResponseValue;
16070 // void UserConfig_free(struct LDKUserConfig this_obj);
16072 export function UserConfig_free(this_obj: number): void {
16073 if(!isWasmInitialized) {
16074 throw new Error("initializeWasm() must be awaited first!");
16076 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
16077 // debug statements here
16079 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16081 export function UserConfig_get_own_channel_config(this_ptr: number): number {
16082 if(!isWasmInitialized) {
16083 throw new Error("initializeWasm() must be awaited first!");
16085 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
16086 return nativeResponseValue;
16088 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
16090 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
16091 if(!isWasmInitialized) {
16092 throw new Error("initializeWasm() must be awaited first!");
16094 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
16095 // debug statements here
16097 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16099 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
16100 if(!isWasmInitialized) {
16101 throw new Error("initializeWasm() must be awaited first!");
16103 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
16104 return nativeResponseValue;
16106 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
16108 export function UserConfig_set_peer_channel_config_limits(this_ptr: number, val: number): void {
16109 if(!isWasmInitialized) {
16110 throw new Error("initializeWasm() must be awaited first!");
16112 const nativeResponseValue = wasm.TS_UserConfig_set_peer_channel_config_limits(this_ptr, val);
16113 // debug statements here
16115 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16117 export function UserConfig_get_channel_options(this_ptr: number): number {
16118 if(!isWasmInitialized) {
16119 throw new Error("initializeWasm() must be awaited first!");
16121 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
16122 return nativeResponseValue;
16124 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
16126 export function UserConfig_set_channel_options(this_ptr: number, val: number): void {
16127 if(!isWasmInitialized) {
16128 throw new Error("initializeWasm() must be awaited first!");
16130 const nativeResponseValue = wasm.TS_UserConfig_set_channel_options(this_ptr, val);
16131 // debug statements here
16133 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16135 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
16136 if(!isWasmInitialized) {
16137 throw new Error("initializeWasm() must be awaited first!");
16139 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
16140 return nativeResponseValue;
16142 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16144 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
16145 if(!isWasmInitialized) {
16146 throw new Error("initializeWasm() must be awaited first!");
16148 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
16149 // debug statements here
16151 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16153 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
16154 if(!isWasmInitialized) {
16155 throw new Error("initializeWasm() must be awaited first!");
16157 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
16158 return nativeResponseValue;
16160 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16162 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
16163 if(!isWasmInitialized) {
16164 throw new Error("initializeWasm() must be awaited first!");
16166 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
16167 // debug statements here
16169 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16171 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
16172 if(!isWasmInitialized) {
16173 throw new Error("initializeWasm() must be awaited first!");
16175 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
16176 return nativeResponseValue;
16178 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16180 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
16181 if(!isWasmInitialized) {
16182 throw new Error("initializeWasm() must be awaited first!");
16184 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
16185 // debug statements here
16187 // 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);
16189 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 {
16190 if(!isWasmInitialized) {
16191 throw new Error("initializeWasm() must be awaited first!");
16193 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);
16194 return nativeResponseValue;
16196 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
16198 export function UserConfig_clone_ptr(arg: number): number {
16199 if(!isWasmInitialized) {
16200 throw new Error("initializeWasm() must be awaited first!");
16202 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
16203 return nativeResponseValue;
16205 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
16207 export function UserConfig_clone(orig: number): number {
16208 if(!isWasmInitialized) {
16209 throw new Error("initializeWasm() must be awaited first!");
16211 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
16212 return nativeResponseValue;
16214 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
16216 export function UserConfig_default(): number {
16217 if(!isWasmInitialized) {
16218 throw new Error("initializeWasm() must be awaited first!");
16220 const nativeResponseValue = wasm.TS_UserConfig_default();
16221 return nativeResponseValue;
16223 // void BestBlock_free(struct LDKBestBlock this_obj);
16225 export function BestBlock_free(this_obj: number): void {
16226 if(!isWasmInitialized) {
16227 throw new Error("initializeWasm() must be awaited first!");
16229 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
16230 // debug statements here
16232 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16234 export function BestBlock_clone_ptr(arg: number): number {
16235 if(!isWasmInitialized) {
16236 throw new Error("initializeWasm() must be awaited first!");
16238 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16239 return nativeResponseValue;
16241 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16243 export function BestBlock_clone(orig: number): number {
16244 if(!isWasmInitialized) {
16245 throw new Error("initializeWasm() must be awaited first!");
16247 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16248 return nativeResponseValue;
16250 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16252 export function BestBlock_from_genesis(network: Network): number {
16253 if(!isWasmInitialized) {
16254 throw new Error("initializeWasm() must be awaited first!");
16256 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16257 return nativeResponseValue;
16259 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16261 export function BestBlock_new(block_hash: number, height: number): number {
16262 if(!isWasmInitialized) {
16263 throw new Error("initializeWasm() must be awaited first!");
16265 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16266 return nativeResponseValue;
16268 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16270 export function BestBlock_block_hash(this_arg: number): number {
16271 if(!isWasmInitialized) {
16272 throw new Error("initializeWasm() must be awaited first!");
16274 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16275 return nativeResponseValue;
16277 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16279 export function BestBlock_height(this_arg: number): number {
16280 if(!isWasmInitialized) {
16281 throw new Error("initializeWasm() must be awaited first!");
16283 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16284 return nativeResponseValue;
16286 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16288 export function AccessError_clone(orig: number): AccessError {
16289 if(!isWasmInitialized) {
16290 throw new Error("initializeWasm() must be awaited first!");
16292 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
16293 return nativeResponseValue;
16295 // enum LDKAccessError AccessError_unknown_chain(void);
16297 export function AccessError_unknown_chain(): AccessError {
16298 if(!isWasmInitialized) {
16299 throw new Error("initializeWasm() must be awaited first!");
16301 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
16302 return nativeResponseValue;
16304 // enum LDKAccessError AccessError_unknown_tx(void);
16306 export function AccessError_unknown_tx(): AccessError {
16307 if(!isWasmInitialized) {
16308 throw new Error("initializeWasm() must be awaited first!");
16310 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
16311 return nativeResponseValue;
16313 // void Access_free(struct LDKAccess this_ptr);
16315 export function Access_free(this_ptr: number): void {
16316 if(!isWasmInitialized) {
16317 throw new Error("initializeWasm() must be awaited first!");
16319 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
16320 // debug statements here
16322 // void Listen_free(struct LDKListen this_ptr);
16324 export function Listen_free(this_ptr: number): void {
16325 if(!isWasmInitialized) {
16326 throw new Error("initializeWasm() must be awaited first!");
16328 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
16329 // debug statements here
16331 // void Confirm_free(struct LDKConfirm this_ptr);
16333 export function Confirm_free(this_ptr: number): void {
16334 if(!isWasmInitialized) {
16335 throw new Error("initializeWasm() must be awaited first!");
16337 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
16338 // debug statements here
16340 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
16342 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
16343 if(!isWasmInitialized) {
16344 throw new Error("initializeWasm() must be awaited first!");
16346 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
16347 return nativeResponseValue;
16349 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
16351 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
16352 if(!isWasmInitialized) {
16353 throw new Error("initializeWasm() must be awaited first!");
16355 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
16356 return nativeResponseValue;
16358 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
16360 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
16361 if(!isWasmInitialized) {
16362 throw new Error("initializeWasm() must be awaited first!");
16364 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
16365 return nativeResponseValue;
16367 // void Watch_free(struct LDKWatch this_ptr);
16369 export function Watch_free(this_ptr: number): void {
16370 if(!isWasmInitialized) {
16371 throw new Error("initializeWasm() must be awaited first!");
16373 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
16374 // debug statements here
16376 // void Filter_free(struct LDKFilter this_ptr);
16378 export function Filter_free(this_ptr: number): void {
16379 if(!isWasmInitialized) {
16380 throw new Error("initializeWasm() must be awaited first!");
16382 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
16383 // debug statements here
16385 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
16387 export function WatchedOutput_free(this_obj: number): void {
16388 if(!isWasmInitialized) {
16389 throw new Error("initializeWasm() must be awaited first!");
16391 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
16392 // debug statements here
16394 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16396 export function WatchedOutput_get_block_hash(this_ptr: number): number {
16397 if(!isWasmInitialized) {
16398 throw new Error("initializeWasm() must be awaited first!");
16400 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
16401 return nativeResponseValue;
16403 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16405 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
16406 if(!isWasmInitialized) {
16407 throw new Error("initializeWasm() must be awaited first!");
16409 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
16410 // debug statements here
16412 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16414 export function WatchedOutput_get_outpoint(this_ptr: number): number {
16415 if(!isWasmInitialized) {
16416 throw new Error("initializeWasm() must be awaited first!");
16418 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
16419 return nativeResponseValue;
16421 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
16423 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
16424 if(!isWasmInitialized) {
16425 throw new Error("initializeWasm() must be awaited first!");
16427 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
16428 // debug statements here
16430 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16432 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
16433 if(!isWasmInitialized) {
16434 throw new Error("initializeWasm() must be awaited first!");
16436 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
16437 return nativeResponseValue;
16439 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
16441 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
16442 if(!isWasmInitialized) {
16443 throw new Error("initializeWasm() must be awaited first!");
16445 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
16446 // debug statements here
16448 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
16450 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
16451 if(!isWasmInitialized) {
16452 throw new Error("initializeWasm() must be awaited first!");
16454 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
16455 return nativeResponseValue;
16457 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
16459 export function WatchedOutput_clone_ptr(arg: number): number {
16460 if(!isWasmInitialized) {
16461 throw new Error("initializeWasm() must be awaited first!");
16463 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
16464 return nativeResponseValue;
16466 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
16468 export function WatchedOutput_clone(orig: number): number {
16469 if(!isWasmInitialized) {
16470 throw new Error("initializeWasm() must be awaited first!");
16472 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
16473 return nativeResponseValue;
16475 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
16477 export function WatchedOutput_hash(o: number): bigint {
16478 if(!isWasmInitialized) {
16479 throw new Error("initializeWasm() must be awaited first!");
16481 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
16482 return nativeResponseValue;
16484 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
16486 export function BroadcasterInterface_free(this_ptr: number): void {
16487 if(!isWasmInitialized) {
16488 throw new Error("initializeWasm() must be awaited first!");
16490 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
16491 // debug statements here
16493 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
16495 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
16496 if(!isWasmInitialized) {
16497 throw new Error("initializeWasm() must be awaited first!");
16499 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
16500 return nativeResponseValue;
16502 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
16504 export function ConfirmationTarget_background(): ConfirmationTarget {
16505 if(!isWasmInitialized) {
16506 throw new Error("initializeWasm() must be awaited first!");
16508 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
16509 return nativeResponseValue;
16511 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
16513 export function ConfirmationTarget_normal(): ConfirmationTarget {
16514 if(!isWasmInitialized) {
16515 throw new Error("initializeWasm() must be awaited first!");
16517 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
16518 return nativeResponseValue;
16520 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
16522 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
16523 if(!isWasmInitialized) {
16524 throw new Error("initializeWasm() must be awaited first!");
16526 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
16527 return nativeResponseValue;
16529 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
16531 export function ConfirmationTarget_eq(a: number, b: number): boolean {
16532 if(!isWasmInitialized) {
16533 throw new Error("initializeWasm() must be awaited first!");
16535 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
16536 return nativeResponseValue;
16538 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
16540 export function FeeEstimator_free(this_ptr: number): void {
16541 if(!isWasmInitialized) {
16542 throw new Error("initializeWasm() must be awaited first!");
16544 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
16545 // debug statements here
16547 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
16549 export function MonitorUpdateId_free(this_obj: number): void {
16550 if(!isWasmInitialized) {
16551 throw new Error("initializeWasm() must be awaited first!");
16553 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
16554 // debug statements here
16556 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
16558 export function MonitorUpdateId_clone_ptr(arg: number): number {
16559 if(!isWasmInitialized) {
16560 throw new Error("initializeWasm() must be awaited first!");
16562 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
16563 return nativeResponseValue;
16565 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
16567 export function MonitorUpdateId_clone(orig: number): number {
16568 if(!isWasmInitialized) {
16569 throw new Error("initializeWasm() must be awaited first!");
16571 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
16572 return nativeResponseValue;
16574 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
16576 export function MonitorUpdateId_hash(o: number): bigint {
16577 if(!isWasmInitialized) {
16578 throw new Error("initializeWasm() must be awaited first!");
16580 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
16581 return nativeResponseValue;
16583 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
16585 export function MonitorUpdateId_eq(a: number, b: number): boolean {
16586 if(!isWasmInitialized) {
16587 throw new Error("initializeWasm() must be awaited first!");
16589 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
16590 return nativeResponseValue;
16592 // void Persist_free(struct LDKPersist this_ptr);
16594 export function Persist_free(this_ptr: number): void {
16595 if(!isWasmInitialized) {
16596 throw new Error("initializeWasm() must be awaited first!");
16598 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
16599 // debug statements here
16601 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
16603 export function LockedChannelMonitor_free(this_obj: number): void {
16604 if(!isWasmInitialized) {
16605 throw new Error("initializeWasm() must be awaited first!");
16607 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
16608 // debug statements here
16610 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
16612 export function ChainMonitor_free(this_obj: number): void {
16613 if(!isWasmInitialized) {
16614 throw new Error("initializeWasm() must be awaited first!");
16616 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
16617 // debug statements here
16619 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
16621 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
16622 if(!isWasmInitialized) {
16623 throw new Error("initializeWasm() must be awaited first!");
16625 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
16626 return nativeResponseValue;
16628 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
16630 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
16631 if(!isWasmInitialized) {
16632 throw new Error("initializeWasm() must be awaited first!");
16634 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
16635 return nativeResponseValue;
16637 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
16639 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
16640 if(!isWasmInitialized) {
16641 throw new Error("initializeWasm() must be awaited first!");
16643 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
16644 return nativeResponseValue;
16646 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16648 export function ChainMonitor_list_monitors(this_arg: number): number {
16649 if(!isWasmInitialized) {
16650 throw new Error("initializeWasm() must be awaited first!");
16652 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
16653 return nativeResponseValue;
16655 // 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);
16657 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
16658 if(!isWasmInitialized) {
16659 throw new Error("initializeWasm() must be awaited first!");
16661 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
16662 return nativeResponseValue;
16664 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16666 export function ChainMonitor_as_Listen(this_arg: number): number {
16667 if(!isWasmInitialized) {
16668 throw new Error("initializeWasm() must be awaited first!");
16670 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
16671 return nativeResponseValue;
16673 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16675 export function ChainMonitor_as_Confirm(this_arg: number): number {
16676 if(!isWasmInitialized) {
16677 throw new Error("initializeWasm() must be awaited first!");
16679 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
16680 return nativeResponseValue;
16682 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16684 export function ChainMonitor_as_Watch(this_arg: number): number {
16685 if(!isWasmInitialized) {
16686 throw new Error("initializeWasm() must be awaited first!");
16688 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
16689 return nativeResponseValue;
16691 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
16693 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
16694 if(!isWasmInitialized) {
16695 throw new Error("initializeWasm() must be awaited first!");
16697 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
16698 return nativeResponseValue;
16700 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
16702 export function ChannelMonitorUpdate_free(this_obj: number): void {
16703 if(!isWasmInitialized) {
16704 throw new Error("initializeWasm() must be awaited first!");
16706 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
16707 // debug statements here
16709 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
16711 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
16712 if(!isWasmInitialized) {
16713 throw new Error("initializeWasm() must be awaited first!");
16715 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
16716 return nativeResponseValue;
16718 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
16720 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
16721 if(!isWasmInitialized) {
16722 throw new Error("initializeWasm() must be awaited first!");
16724 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
16725 // debug statements here
16727 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
16729 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
16730 if(!isWasmInitialized) {
16731 throw new Error("initializeWasm() must be awaited first!");
16733 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
16734 return nativeResponseValue;
16736 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
16738 export function ChannelMonitorUpdate_clone(orig: number): number {
16739 if(!isWasmInitialized) {
16740 throw new Error("initializeWasm() must be awaited first!");
16742 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
16743 return nativeResponseValue;
16745 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
16747 export function ChannelMonitorUpdate_write(obj: number): number {
16748 if(!isWasmInitialized) {
16749 throw new Error("initializeWasm() must be awaited first!");
16751 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
16752 return nativeResponseValue;
16754 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
16756 export function ChannelMonitorUpdate_read(ser: number): number {
16757 if(!isWasmInitialized) {
16758 throw new Error("initializeWasm() must be awaited first!");
16760 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
16761 return nativeResponseValue;
16763 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
16765 export function MonitorEvent_free(this_ptr: number): void {
16766 if(!isWasmInitialized) {
16767 throw new Error("initializeWasm() must be awaited first!");
16769 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
16770 // debug statements here
16772 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
16774 export function MonitorEvent_clone_ptr(arg: number): number {
16775 if(!isWasmInitialized) {
16776 throw new Error("initializeWasm() must be awaited first!");
16778 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
16779 return nativeResponseValue;
16781 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
16783 export function MonitorEvent_clone(orig: number): number {
16784 if(!isWasmInitialized) {
16785 throw new Error("initializeWasm() must be awaited first!");
16787 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
16788 return nativeResponseValue;
16790 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
16792 export function MonitorEvent_htlcevent(a: number): number {
16793 if(!isWasmInitialized) {
16794 throw new Error("initializeWasm() must be awaited first!");
16796 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
16797 return nativeResponseValue;
16799 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
16801 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
16802 if(!isWasmInitialized) {
16803 throw new Error("initializeWasm() must be awaited first!");
16805 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
16806 return nativeResponseValue;
16808 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
16810 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
16811 if(!isWasmInitialized) {
16812 throw new Error("initializeWasm() must be awaited first!");
16814 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
16815 return nativeResponseValue;
16817 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
16819 export function MonitorEvent_update_failed(a: number): number {
16820 if(!isWasmInitialized) {
16821 throw new Error("initializeWasm() must be awaited first!");
16823 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
16824 return nativeResponseValue;
16826 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
16828 export function MonitorEvent_write(obj: number): number {
16829 if(!isWasmInitialized) {
16830 throw new Error("initializeWasm() must be awaited first!");
16832 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
16833 return nativeResponseValue;
16835 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
16837 export function MonitorEvent_read(ser: number): number {
16838 if(!isWasmInitialized) {
16839 throw new Error("initializeWasm() must be awaited first!");
16841 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
16842 return nativeResponseValue;
16844 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
16846 export function HTLCUpdate_free(this_obj: number): void {
16847 if(!isWasmInitialized) {
16848 throw new Error("initializeWasm() must be awaited first!");
16850 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
16851 // debug statements here
16853 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
16855 export function HTLCUpdate_clone_ptr(arg: number): number {
16856 if(!isWasmInitialized) {
16857 throw new Error("initializeWasm() must be awaited first!");
16859 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
16860 return nativeResponseValue;
16862 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
16864 export function HTLCUpdate_clone(orig: number): number {
16865 if(!isWasmInitialized) {
16866 throw new Error("initializeWasm() must be awaited first!");
16868 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
16869 return nativeResponseValue;
16871 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
16873 export function HTLCUpdate_write(obj: number): number {
16874 if(!isWasmInitialized) {
16875 throw new Error("initializeWasm() must be awaited first!");
16877 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
16878 return nativeResponseValue;
16880 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
16882 export function HTLCUpdate_read(ser: number): number {
16883 if(!isWasmInitialized) {
16884 throw new Error("initializeWasm() must be awaited first!");
16886 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
16887 return nativeResponseValue;
16889 // void Balance_free(struct LDKBalance this_ptr);
16891 export function Balance_free(this_ptr: number): void {
16892 if(!isWasmInitialized) {
16893 throw new Error("initializeWasm() must be awaited first!");
16895 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
16896 // debug statements here
16898 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
16900 export function Balance_clone_ptr(arg: number): number {
16901 if(!isWasmInitialized) {
16902 throw new Error("initializeWasm() must be awaited first!");
16904 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
16905 return nativeResponseValue;
16907 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
16909 export function Balance_clone(orig: number): number {
16910 if(!isWasmInitialized) {
16911 throw new Error("initializeWasm() must be awaited first!");
16913 const nativeResponseValue = wasm.TS_Balance_clone(orig);
16914 return nativeResponseValue;
16916 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
16918 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
16919 if(!isWasmInitialized) {
16920 throw new Error("initializeWasm() must be awaited first!");
16922 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
16923 return nativeResponseValue;
16925 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
16927 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
16928 if(!isWasmInitialized) {
16929 throw new Error("initializeWasm() must be awaited first!");
16931 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
16932 return nativeResponseValue;
16934 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
16936 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
16937 if(!isWasmInitialized) {
16938 throw new Error("initializeWasm() must be awaited first!");
16940 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
16941 return nativeResponseValue;
16943 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
16945 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
16946 if(!isWasmInitialized) {
16947 throw new Error("initializeWasm() must be awaited first!");
16949 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
16950 return nativeResponseValue;
16952 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
16954 export function Balance_eq(a: number, b: number): boolean {
16955 if(!isWasmInitialized) {
16956 throw new Error("initializeWasm() must be awaited first!");
16958 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
16959 return nativeResponseValue;
16961 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
16963 export function ChannelMonitor_free(this_obj: number): void {
16964 if(!isWasmInitialized) {
16965 throw new Error("initializeWasm() must be awaited first!");
16967 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
16968 // debug statements here
16970 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
16972 export function ChannelMonitor_clone_ptr(arg: number): number {
16973 if(!isWasmInitialized) {
16974 throw new Error("initializeWasm() must be awaited first!");
16976 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
16977 return nativeResponseValue;
16979 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
16981 export function ChannelMonitor_clone(orig: number): number {
16982 if(!isWasmInitialized) {
16983 throw new Error("initializeWasm() must be awaited first!");
16985 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
16986 return nativeResponseValue;
16988 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
16990 export function ChannelMonitor_write(obj: number): number {
16991 if(!isWasmInitialized) {
16992 throw new Error("initializeWasm() must be awaited first!");
16994 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
16995 return nativeResponseValue;
16997 // 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);
16999 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
17000 if(!isWasmInitialized) {
17001 throw new Error("initializeWasm() must be awaited first!");
17003 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
17004 return nativeResponseValue;
17006 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17008 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
17009 if(!isWasmInitialized) {
17010 throw new Error("initializeWasm() must be awaited first!");
17012 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
17013 return nativeResponseValue;
17015 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17017 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
17018 if(!isWasmInitialized) {
17019 throw new Error("initializeWasm() must be awaited first!");
17021 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
17022 return nativeResponseValue;
17024 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17026 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
17027 if(!isWasmInitialized) {
17028 throw new Error("initializeWasm() must be awaited first!");
17030 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
17031 return nativeResponseValue;
17033 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
17035 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
17036 if(!isWasmInitialized) {
17037 throw new Error("initializeWasm() must be awaited first!");
17039 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
17040 // debug statements here
17042 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17044 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
17045 if(!isWasmInitialized) {
17046 throw new Error("initializeWasm() must be awaited first!");
17048 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
17049 return nativeResponseValue;
17051 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17053 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
17054 if(!isWasmInitialized) {
17055 throw new Error("initializeWasm() must be awaited first!");
17057 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
17058 return nativeResponseValue;
17060 // 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);
17062 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
17063 if(!isWasmInitialized) {
17064 throw new Error("initializeWasm() must be awaited first!");
17066 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
17067 return nativeResponseValue;
17069 // 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);
17071 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17072 if(!isWasmInitialized) {
17073 throw new Error("initializeWasm() must be awaited first!");
17075 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17076 return nativeResponseValue;
17078 // 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);
17080 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
17081 if(!isWasmInitialized) {
17082 throw new Error("initializeWasm() must be awaited first!");
17084 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
17085 // debug statements here
17087 // 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);
17089 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17090 if(!isWasmInitialized) {
17091 throw new Error("initializeWasm() must be awaited first!");
17093 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17094 return nativeResponseValue;
17096 // 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);
17098 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
17099 if(!isWasmInitialized) {
17100 throw new Error("initializeWasm() must be awaited first!");
17102 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
17103 // debug statements here
17105 // 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);
17107 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17108 if(!isWasmInitialized) {
17109 throw new Error("initializeWasm() must be awaited first!");
17111 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
17112 return nativeResponseValue;
17114 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17116 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
17117 if(!isWasmInitialized) {
17118 throw new Error("initializeWasm() must be awaited first!");
17120 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
17121 return nativeResponseValue;
17123 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17125 export function ChannelMonitor_current_best_block(this_arg: number): number {
17126 if(!isWasmInitialized) {
17127 throw new Error("initializeWasm() must be awaited first!");
17129 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
17130 return nativeResponseValue;
17132 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17134 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
17135 if(!isWasmInitialized) {
17136 throw new Error("initializeWasm() must be awaited first!");
17138 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
17139 return nativeResponseValue;
17141 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
17143 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
17144 if(!isWasmInitialized) {
17145 throw new Error("initializeWasm() must be awaited first!");
17147 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
17148 return nativeResponseValue;
17150 // void OutPoint_free(struct LDKOutPoint this_obj);
17152 export function OutPoint_free(this_obj: number): void {
17153 if(!isWasmInitialized) {
17154 throw new Error("initializeWasm() must be awaited first!");
17156 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
17157 // debug statements here
17159 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
17161 export function OutPoint_get_txid(this_ptr: number): number {
17162 if(!isWasmInitialized) {
17163 throw new Error("initializeWasm() must be awaited first!");
17165 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
17166 return nativeResponseValue;
17168 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17170 export function OutPoint_set_txid(this_ptr: number, val: number): void {
17171 if(!isWasmInitialized) {
17172 throw new Error("initializeWasm() must be awaited first!");
17174 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
17175 // debug statements here
17177 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
17179 export function OutPoint_get_index(this_ptr: number): number {
17180 if(!isWasmInitialized) {
17181 throw new Error("initializeWasm() must be awaited first!");
17183 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
17184 return nativeResponseValue;
17186 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
17188 export function OutPoint_set_index(this_ptr: number, val: number): void {
17189 if(!isWasmInitialized) {
17190 throw new Error("initializeWasm() must be awaited first!");
17192 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
17193 // debug statements here
17195 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
17197 export function OutPoint_new(txid_arg: number, index_arg: number): number {
17198 if(!isWasmInitialized) {
17199 throw new Error("initializeWasm() must be awaited first!");
17201 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
17202 return nativeResponseValue;
17204 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
17206 export function OutPoint_clone_ptr(arg: number): number {
17207 if(!isWasmInitialized) {
17208 throw new Error("initializeWasm() must be awaited first!");
17210 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
17211 return nativeResponseValue;
17213 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
17215 export function OutPoint_clone(orig: number): number {
17216 if(!isWasmInitialized) {
17217 throw new Error("initializeWasm() must be awaited first!");
17219 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
17220 return nativeResponseValue;
17222 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
17224 export function OutPoint_eq(a: number, b: number): boolean {
17225 if(!isWasmInitialized) {
17226 throw new Error("initializeWasm() must be awaited first!");
17228 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
17229 return nativeResponseValue;
17231 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17233 export function OutPoint_hash(o: number): bigint {
17234 if(!isWasmInitialized) {
17235 throw new Error("initializeWasm() must be awaited first!");
17237 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17238 return nativeResponseValue;
17240 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17242 export function OutPoint_to_channel_id(this_arg: number): number {
17243 if(!isWasmInitialized) {
17244 throw new Error("initializeWasm() must be awaited first!");
17246 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17247 return nativeResponseValue;
17249 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17251 export function OutPoint_write(obj: number): number {
17252 if(!isWasmInitialized) {
17253 throw new Error("initializeWasm() must be awaited first!");
17255 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17256 return nativeResponseValue;
17258 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17260 export function OutPoint_read(ser: number): number {
17261 if(!isWasmInitialized) {
17262 throw new Error("initializeWasm() must be awaited first!");
17264 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17265 return nativeResponseValue;
17267 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17269 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17270 if(!isWasmInitialized) {
17271 throw new Error("initializeWasm() must be awaited first!");
17273 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17274 // debug statements here
17276 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17278 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17279 if(!isWasmInitialized) {
17280 throw new Error("initializeWasm() must be awaited first!");
17282 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17283 return nativeResponseValue;
17285 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17287 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17288 if(!isWasmInitialized) {
17289 throw new Error("initializeWasm() must be awaited first!");
17291 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17292 // debug statements here
17294 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17296 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
17297 if(!isWasmInitialized) {
17298 throw new Error("initializeWasm() must be awaited first!");
17300 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
17301 return nativeResponseValue;
17303 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17305 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
17306 if(!isWasmInitialized) {
17307 throw new Error("initializeWasm() must be awaited first!");
17309 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
17310 // debug statements here
17312 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17314 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
17315 if(!isWasmInitialized) {
17316 throw new Error("initializeWasm() must be awaited first!");
17318 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
17319 return nativeResponseValue;
17321 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
17323 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
17324 if(!isWasmInitialized) {
17325 throw new Error("initializeWasm() must be awaited first!");
17327 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
17328 // debug statements here
17330 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17332 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17333 if(!isWasmInitialized) {
17334 throw new Error("initializeWasm() must be awaited first!");
17336 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
17337 // debug statements here
17339 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17341 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
17342 if(!isWasmInitialized) {
17343 throw new Error("initializeWasm() must be awaited first!");
17345 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
17346 return nativeResponseValue;
17348 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17350 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
17351 if(!isWasmInitialized) {
17352 throw new Error("initializeWasm() must be awaited first!");
17354 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
17355 // debug statements here
17357 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17359 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17360 if(!isWasmInitialized) {
17361 throw new Error("initializeWasm() must be awaited first!");
17363 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17364 return nativeResponseValue;
17366 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17368 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17369 if(!isWasmInitialized) {
17370 throw new Error("initializeWasm() must be awaited first!");
17372 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17373 // debug statements here
17375 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17377 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17378 if(!isWasmInitialized) {
17379 throw new Error("initializeWasm() must be awaited first!");
17381 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17382 return nativeResponseValue;
17384 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17386 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17387 if(!isWasmInitialized) {
17388 throw new Error("initializeWasm() must be awaited first!");
17390 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17391 // debug statements here
17393 // 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);
17395 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 {
17396 if(!isWasmInitialized) {
17397 throw new Error("initializeWasm() must be awaited first!");
17399 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);
17400 return nativeResponseValue;
17402 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
17404 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
17405 if(!isWasmInitialized) {
17406 throw new Error("initializeWasm() must be awaited first!");
17408 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
17409 return nativeResponseValue;
17411 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
17413 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
17414 if(!isWasmInitialized) {
17415 throw new Error("initializeWasm() must be awaited first!");
17417 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
17418 return nativeResponseValue;
17420 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
17422 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
17423 if(!isWasmInitialized) {
17424 throw new Error("initializeWasm() must be awaited first!");
17426 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
17427 return nativeResponseValue;
17429 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
17431 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
17432 if(!isWasmInitialized) {
17433 throw new Error("initializeWasm() must be awaited first!");
17435 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
17436 return nativeResponseValue;
17438 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
17440 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
17441 if(!isWasmInitialized) {
17442 throw new Error("initializeWasm() must be awaited first!");
17444 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
17445 // debug statements here
17447 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17449 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17450 if(!isWasmInitialized) {
17451 throw new Error("initializeWasm() must be awaited first!");
17453 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
17454 return nativeResponseValue;
17456 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17458 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17459 if(!isWasmInitialized) {
17460 throw new Error("initializeWasm() must be awaited first!");
17462 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17463 // debug statements here
17465 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17467 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17468 if(!isWasmInitialized) {
17469 throw new Error("initializeWasm() must be awaited first!");
17471 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
17472 // debug statements here
17474 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17476 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17477 if(!isWasmInitialized) {
17478 throw new Error("initializeWasm() must be awaited first!");
17480 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17481 return nativeResponseValue;
17483 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17485 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17486 if(!isWasmInitialized) {
17487 throw new Error("initializeWasm() must be awaited first!");
17489 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17490 // debug statements here
17492 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17494 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17495 if(!isWasmInitialized) {
17496 throw new Error("initializeWasm() must be awaited first!");
17498 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17499 return nativeResponseValue;
17501 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17503 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17504 if(!isWasmInitialized) {
17505 throw new Error("initializeWasm() must be awaited first!");
17507 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17508 // debug statements here
17510 // 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);
17512 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
17513 if(!isWasmInitialized) {
17514 throw new Error("initializeWasm() must be awaited first!");
17516 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
17517 return nativeResponseValue;
17519 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
17521 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
17522 if(!isWasmInitialized) {
17523 throw new Error("initializeWasm() must be awaited first!");
17525 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
17526 return nativeResponseValue;
17528 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
17530 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
17531 if(!isWasmInitialized) {
17532 throw new Error("initializeWasm() must be awaited first!");
17534 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
17535 return nativeResponseValue;
17537 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
17539 export function StaticPaymentOutputDescriptor_write(obj: number): number {
17540 if(!isWasmInitialized) {
17541 throw new Error("initializeWasm() must be awaited first!");
17543 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
17544 return nativeResponseValue;
17546 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
17548 export function StaticPaymentOutputDescriptor_read(ser: number): number {
17549 if(!isWasmInitialized) {
17550 throw new Error("initializeWasm() must be awaited first!");
17552 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
17553 return nativeResponseValue;
17555 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
17557 export function SpendableOutputDescriptor_free(this_ptr: number): void {
17558 if(!isWasmInitialized) {
17559 throw new Error("initializeWasm() must be awaited first!");
17561 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
17562 // debug statements here
17564 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
17566 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
17567 if(!isWasmInitialized) {
17568 throw new Error("initializeWasm() must be awaited first!");
17570 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
17571 return nativeResponseValue;
17573 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
17575 export function SpendableOutputDescriptor_clone(orig: number): number {
17576 if(!isWasmInitialized) {
17577 throw new Error("initializeWasm() must be awaited first!");
17579 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
17580 return nativeResponseValue;
17582 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
17584 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
17585 if(!isWasmInitialized) {
17586 throw new Error("initializeWasm() must be awaited first!");
17588 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
17589 return nativeResponseValue;
17591 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
17593 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
17594 if(!isWasmInitialized) {
17595 throw new Error("initializeWasm() must be awaited first!");
17597 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
17598 return nativeResponseValue;
17600 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
17602 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
17603 if(!isWasmInitialized) {
17604 throw new Error("initializeWasm() must be awaited first!");
17606 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
17607 return nativeResponseValue;
17609 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
17611 export function SpendableOutputDescriptor_write(obj: number): number {
17612 if(!isWasmInitialized) {
17613 throw new Error("initializeWasm() must be awaited first!");
17615 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
17616 return nativeResponseValue;
17618 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
17620 export function SpendableOutputDescriptor_read(ser: number): number {
17621 if(!isWasmInitialized) {
17622 throw new Error("initializeWasm() must be awaited first!");
17624 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
17625 return nativeResponseValue;
17627 // void BaseSign_free(struct LDKBaseSign this_ptr);
17629 export function BaseSign_free(this_ptr: number): void {
17630 if(!isWasmInitialized) {
17631 throw new Error("initializeWasm() must be awaited first!");
17633 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
17634 // debug statements here
17636 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
17638 export function Sign_clone_ptr(arg: number): number {
17639 if(!isWasmInitialized) {
17640 throw new Error("initializeWasm() must be awaited first!");
17642 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
17643 return nativeResponseValue;
17645 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
17647 export function Sign_clone(orig: number): number {
17648 if(!isWasmInitialized) {
17649 throw new Error("initializeWasm() must be awaited first!");
17651 const nativeResponseValue = wasm.TS_Sign_clone(orig);
17652 return nativeResponseValue;
17654 // void Sign_free(struct LDKSign this_ptr);
17656 export function Sign_free(this_ptr: number): void {
17657 if(!isWasmInitialized) {
17658 throw new Error("initializeWasm() must be awaited first!");
17660 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
17661 // debug statements here
17663 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
17665 export function Recipient_clone(orig: number): Recipient {
17666 if(!isWasmInitialized) {
17667 throw new Error("initializeWasm() must be awaited first!");
17669 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
17670 return nativeResponseValue;
17672 // enum LDKRecipient Recipient_node(void);
17674 export function Recipient_node(): Recipient {
17675 if(!isWasmInitialized) {
17676 throw new Error("initializeWasm() must be awaited first!");
17678 const nativeResponseValue = wasm.TS_Recipient_node();
17679 return nativeResponseValue;
17681 // enum LDKRecipient Recipient_phantom_node(void);
17683 export function Recipient_phantom_node(): Recipient {
17684 if(!isWasmInitialized) {
17685 throw new Error("initializeWasm() must be awaited first!");
17687 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
17688 return nativeResponseValue;
17690 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
17692 export function KeysInterface_free(this_ptr: number): void {
17693 if(!isWasmInitialized) {
17694 throw new Error("initializeWasm() must be awaited first!");
17696 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
17697 // debug statements here
17699 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
17701 export function InMemorySigner_free(this_obj: number): void {
17702 if(!isWasmInitialized) {
17703 throw new Error("initializeWasm() must be awaited first!");
17705 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
17706 // debug statements here
17708 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17710 export function InMemorySigner_get_funding_key(this_ptr: number): number {
17711 if(!isWasmInitialized) {
17712 throw new Error("initializeWasm() must be awaited first!");
17714 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
17715 return nativeResponseValue;
17717 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17719 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
17720 if(!isWasmInitialized) {
17721 throw new Error("initializeWasm() must be awaited first!");
17723 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
17724 // debug statements here
17726 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17728 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
17729 if(!isWasmInitialized) {
17730 throw new Error("initializeWasm() must be awaited first!");
17732 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
17733 return nativeResponseValue;
17735 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17737 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
17738 if(!isWasmInitialized) {
17739 throw new Error("initializeWasm() must be awaited first!");
17741 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
17742 // debug statements here
17744 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17746 export function InMemorySigner_get_payment_key(this_ptr: number): number {
17747 if(!isWasmInitialized) {
17748 throw new Error("initializeWasm() must be awaited first!");
17750 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
17751 return nativeResponseValue;
17753 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17755 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
17756 if(!isWasmInitialized) {
17757 throw new Error("initializeWasm() must be awaited first!");
17759 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
17760 // debug statements here
17762 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17764 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
17765 if(!isWasmInitialized) {
17766 throw new Error("initializeWasm() must be awaited first!");
17768 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
17769 return nativeResponseValue;
17771 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17773 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
17774 if(!isWasmInitialized) {
17775 throw new Error("initializeWasm() must be awaited first!");
17777 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
17778 // debug statements here
17780 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17782 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
17783 if(!isWasmInitialized) {
17784 throw new Error("initializeWasm() must be awaited first!");
17786 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
17787 return nativeResponseValue;
17789 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
17791 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
17792 if(!isWasmInitialized) {
17793 throw new Error("initializeWasm() must be awaited first!");
17795 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
17796 // debug statements here
17798 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
17800 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
17801 if(!isWasmInitialized) {
17802 throw new Error("initializeWasm() must be awaited first!");
17804 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
17805 return nativeResponseValue;
17807 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17809 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
17810 if(!isWasmInitialized) {
17811 throw new Error("initializeWasm() must be awaited first!");
17813 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
17814 // debug statements here
17816 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
17818 export function InMemorySigner_clone_ptr(arg: number): number {
17819 if(!isWasmInitialized) {
17820 throw new Error("initializeWasm() must be awaited first!");
17822 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
17823 return nativeResponseValue;
17825 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
17827 export function InMemorySigner_clone(orig: number): number {
17828 if(!isWasmInitialized) {
17829 throw new Error("initializeWasm() must be awaited first!");
17831 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
17832 return nativeResponseValue;
17834 // 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);
17836 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 {
17837 if(!isWasmInitialized) {
17838 throw new Error("initializeWasm() must be awaited first!");
17840 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);
17841 return nativeResponseValue;
17843 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17845 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
17846 if(!isWasmInitialized) {
17847 throw new Error("initializeWasm() must be awaited first!");
17849 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
17850 return nativeResponseValue;
17852 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17854 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
17855 if(!isWasmInitialized) {
17856 throw new Error("initializeWasm() must be awaited first!");
17858 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
17859 return nativeResponseValue;
17861 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17863 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
17864 if(!isWasmInitialized) {
17865 throw new Error("initializeWasm() must be awaited first!");
17867 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
17868 return nativeResponseValue;
17870 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17872 export function InMemorySigner_is_outbound(this_arg: number): boolean {
17873 if(!isWasmInitialized) {
17874 throw new Error("initializeWasm() must be awaited first!");
17876 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
17877 return nativeResponseValue;
17879 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17881 export function InMemorySigner_funding_outpoint(this_arg: number): number {
17882 if(!isWasmInitialized) {
17883 throw new Error("initializeWasm() must be awaited first!");
17885 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
17886 return nativeResponseValue;
17888 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17890 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
17891 if(!isWasmInitialized) {
17892 throw new Error("initializeWasm() must be awaited first!");
17894 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
17895 return nativeResponseValue;
17897 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17899 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
17900 if(!isWasmInitialized) {
17901 throw new Error("initializeWasm() must be awaited first!");
17903 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
17904 return nativeResponseValue;
17906 // 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);
17908 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
17909 if(!isWasmInitialized) {
17910 throw new Error("initializeWasm() must be awaited first!");
17912 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
17913 return nativeResponseValue;
17915 // 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);
17917 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
17918 if(!isWasmInitialized) {
17919 throw new Error("initializeWasm() must be awaited first!");
17921 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
17922 return nativeResponseValue;
17924 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17926 export function InMemorySigner_as_BaseSign(this_arg: number): number {
17927 if(!isWasmInitialized) {
17928 throw new Error("initializeWasm() must be awaited first!");
17930 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
17931 return nativeResponseValue;
17933 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
17935 export function InMemorySigner_as_Sign(this_arg: number): number {
17936 if(!isWasmInitialized) {
17937 throw new Error("initializeWasm() must be awaited first!");
17939 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
17940 return nativeResponseValue;
17942 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
17944 export function InMemorySigner_write(obj: number): number {
17945 if(!isWasmInitialized) {
17946 throw new Error("initializeWasm() must be awaited first!");
17948 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
17949 return nativeResponseValue;
17951 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
17953 export function InMemorySigner_read(ser: number, arg: number): number {
17954 if(!isWasmInitialized) {
17955 throw new Error("initializeWasm() must be awaited first!");
17957 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
17958 return nativeResponseValue;
17960 // void KeysManager_free(struct LDKKeysManager this_obj);
17962 export function KeysManager_free(this_obj: number): void {
17963 if(!isWasmInitialized) {
17964 throw new Error("initializeWasm() must be awaited first!");
17966 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
17967 // debug statements here
17969 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
17971 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
17972 if(!isWasmInitialized) {
17973 throw new Error("initializeWasm() must be awaited first!");
17975 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
17976 return nativeResponseValue;
17978 // 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]);
17980 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
17981 if(!isWasmInitialized) {
17982 throw new Error("initializeWasm() must be awaited first!");
17984 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
17985 return nativeResponseValue;
17987 // 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);
17989 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
17990 if(!isWasmInitialized) {
17991 throw new Error("initializeWasm() must be awaited first!");
17993 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
17994 return nativeResponseValue;
17996 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
17998 export function KeysManager_as_KeysInterface(this_arg: number): number {
17999 if(!isWasmInitialized) {
18000 throw new Error("initializeWasm() must be awaited first!");
18002 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
18003 return nativeResponseValue;
18005 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
18007 export function PhantomKeysManager_free(this_obj: number): void {
18008 if(!isWasmInitialized) {
18009 throw new Error("initializeWasm() must be awaited first!");
18011 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
18012 // debug statements here
18014 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
18016 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
18017 if(!isWasmInitialized) {
18018 throw new Error("initializeWasm() must be awaited first!");
18020 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
18021 return nativeResponseValue;
18023 // 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]);
18025 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
18026 if(!isWasmInitialized) {
18027 throw new Error("initializeWasm() must be awaited first!");
18029 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
18030 return nativeResponseValue;
18032 // 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);
18034 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18035 if(!isWasmInitialized) {
18036 throw new Error("initializeWasm() must be awaited first!");
18038 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18039 return nativeResponseValue;
18041 // 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]);
18043 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18044 if(!isWasmInitialized) {
18045 throw new Error("initializeWasm() must be awaited first!");
18047 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18048 return nativeResponseValue;
18050 // void ChannelManager_free(struct LDKChannelManager this_obj);
18052 export function ChannelManager_free(this_obj: number): void {
18053 if(!isWasmInitialized) {
18054 throw new Error("initializeWasm() must be awaited first!");
18056 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
18057 // debug statements here
18059 // void ChainParameters_free(struct LDKChainParameters this_obj);
18061 export function ChainParameters_free(this_obj: number): void {
18062 if(!isWasmInitialized) {
18063 throw new Error("initializeWasm() must be awaited first!");
18065 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
18066 // debug statements here
18068 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18070 export function ChainParameters_get_network(this_ptr: number): Network {
18071 if(!isWasmInitialized) {
18072 throw new Error("initializeWasm() must be awaited first!");
18074 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
18075 return nativeResponseValue;
18077 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
18079 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
18080 if(!isWasmInitialized) {
18081 throw new Error("initializeWasm() must be awaited first!");
18083 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
18084 // debug statements here
18086 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18088 export function ChainParameters_get_best_block(this_ptr: number): number {
18089 if(!isWasmInitialized) {
18090 throw new Error("initializeWasm() must be awaited first!");
18092 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
18093 return nativeResponseValue;
18095 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
18097 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
18098 if(!isWasmInitialized) {
18099 throw new Error("initializeWasm() must be awaited first!");
18101 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
18102 // debug statements here
18104 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
18106 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
18107 if(!isWasmInitialized) {
18108 throw new Error("initializeWasm() must be awaited first!");
18110 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
18111 return nativeResponseValue;
18113 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
18115 export function ChainParameters_clone_ptr(arg: number): number {
18116 if(!isWasmInitialized) {
18117 throw new Error("initializeWasm() must be awaited first!");
18119 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
18120 return nativeResponseValue;
18122 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
18124 export function ChainParameters_clone(orig: number): number {
18125 if(!isWasmInitialized) {
18126 throw new Error("initializeWasm() must be awaited first!");
18128 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
18129 return nativeResponseValue;
18131 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
18133 export function CounterpartyForwardingInfo_free(this_obj: number): void {
18134 if(!isWasmInitialized) {
18135 throw new Error("initializeWasm() must be awaited first!");
18137 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
18138 // debug statements here
18140 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18142 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
18143 if(!isWasmInitialized) {
18144 throw new Error("initializeWasm() must be awaited first!");
18146 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
18147 return nativeResponseValue;
18149 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18151 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
18152 if(!isWasmInitialized) {
18153 throw new Error("initializeWasm() must be awaited first!");
18155 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
18156 // debug statements here
18158 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18160 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
18161 if(!isWasmInitialized) {
18162 throw new Error("initializeWasm() must be awaited first!");
18164 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
18165 return nativeResponseValue;
18167 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18169 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
18170 if(!isWasmInitialized) {
18171 throw new Error("initializeWasm() must be awaited first!");
18173 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
18174 // debug statements here
18176 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18178 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
18179 if(!isWasmInitialized) {
18180 throw new Error("initializeWasm() must be awaited first!");
18182 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
18183 return nativeResponseValue;
18185 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
18187 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
18188 if(!isWasmInitialized) {
18189 throw new Error("initializeWasm() must be awaited first!");
18191 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
18192 // debug statements here
18194 // 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);
18196 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
18197 if(!isWasmInitialized) {
18198 throw new Error("initializeWasm() must be awaited first!");
18200 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
18201 return nativeResponseValue;
18203 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
18205 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
18206 if(!isWasmInitialized) {
18207 throw new Error("initializeWasm() must be awaited first!");
18209 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
18210 return nativeResponseValue;
18212 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
18214 export function CounterpartyForwardingInfo_clone(orig: number): number {
18215 if(!isWasmInitialized) {
18216 throw new Error("initializeWasm() must be awaited first!");
18218 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
18219 return nativeResponseValue;
18221 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
18223 export function ChannelCounterparty_free(this_obj: number): void {
18224 if(!isWasmInitialized) {
18225 throw new Error("initializeWasm() must be awaited first!");
18227 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
18228 // debug statements here
18230 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18232 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18233 if(!isWasmInitialized) {
18234 throw new Error("initializeWasm() must be awaited first!");
18236 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18237 return nativeResponseValue;
18239 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18241 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18242 if(!isWasmInitialized) {
18243 throw new Error("initializeWasm() must be awaited first!");
18245 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18246 // debug statements here
18248 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18250 export function ChannelCounterparty_get_features(this_ptr: number): number {
18251 if(!isWasmInitialized) {
18252 throw new Error("initializeWasm() must be awaited first!");
18254 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18255 return nativeResponseValue;
18257 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18259 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18260 if(!isWasmInitialized) {
18261 throw new Error("initializeWasm() must be awaited first!");
18263 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18264 // debug statements here
18266 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18268 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18269 if(!isWasmInitialized) {
18270 throw new Error("initializeWasm() must be awaited first!");
18272 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18273 return nativeResponseValue;
18275 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18277 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18278 if(!isWasmInitialized) {
18279 throw new Error("initializeWasm() must be awaited first!");
18281 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18282 // debug statements here
18284 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18286 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18287 if(!isWasmInitialized) {
18288 throw new Error("initializeWasm() must be awaited first!");
18290 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
18291 return nativeResponseValue;
18293 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
18295 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
18296 if(!isWasmInitialized) {
18297 throw new Error("initializeWasm() must be awaited first!");
18299 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
18300 // debug statements here
18302 // 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);
18304 export function ChannelCounterparty_new(node_id_arg: number, features_arg: number, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: number): number {
18305 if(!isWasmInitialized) {
18306 throw new Error("initializeWasm() must be awaited first!");
18308 const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg);
18309 return nativeResponseValue;
18311 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
18313 export function ChannelCounterparty_clone_ptr(arg: number): number {
18314 if(!isWasmInitialized) {
18315 throw new Error("initializeWasm() must be awaited first!");
18317 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
18318 return nativeResponseValue;
18320 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
18322 export function ChannelCounterparty_clone(orig: number): number {
18323 if(!isWasmInitialized) {
18324 throw new Error("initializeWasm() must be awaited first!");
18326 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
18327 return nativeResponseValue;
18329 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
18331 export function ChannelDetails_free(this_obj: number): void {
18332 if(!isWasmInitialized) {
18333 throw new Error("initializeWasm() must be awaited first!");
18335 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
18336 // debug statements here
18338 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
18340 export function ChannelDetails_get_channel_id(this_ptr: number): number {
18341 if(!isWasmInitialized) {
18342 throw new Error("initializeWasm() must be awaited first!");
18344 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
18345 return nativeResponseValue;
18347 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18349 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
18350 if(!isWasmInitialized) {
18351 throw new Error("initializeWasm() must be awaited first!");
18353 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
18354 // debug statements here
18356 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18358 export function ChannelDetails_get_counterparty(this_ptr: number): number {
18359 if(!isWasmInitialized) {
18360 throw new Error("initializeWasm() must be awaited first!");
18362 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
18363 return nativeResponseValue;
18365 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
18367 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
18368 if(!isWasmInitialized) {
18369 throw new Error("initializeWasm() must be awaited first!");
18371 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
18372 // debug statements here
18374 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18376 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
18377 if(!isWasmInitialized) {
18378 throw new Error("initializeWasm() must be awaited first!");
18380 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
18381 return nativeResponseValue;
18383 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18385 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
18386 if(!isWasmInitialized) {
18387 throw new Error("initializeWasm() must be awaited first!");
18389 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
18390 // debug statements here
18392 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18394 export function ChannelDetails_get_channel_type(this_ptr: number): number {
18395 if(!isWasmInitialized) {
18396 throw new Error("initializeWasm() must be awaited first!");
18398 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
18399 return nativeResponseValue;
18401 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
18403 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
18404 if(!isWasmInitialized) {
18405 throw new Error("initializeWasm() must be awaited first!");
18407 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
18408 // debug statements here
18410 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18412 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
18413 if(!isWasmInitialized) {
18414 throw new Error("initializeWasm() must be awaited first!");
18416 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
18417 return nativeResponseValue;
18419 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18421 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
18422 if(!isWasmInitialized) {
18423 throw new Error("initializeWasm() must be awaited first!");
18425 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
18426 // debug statements here
18428 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18430 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
18431 if(!isWasmInitialized) {
18432 throw new Error("initializeWasm() must be awaited first!");
18434 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
18435 return nativeResponseValue;
18437 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18439 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
18440 if(!isWasmInitialized) {
18441 throw new Error("initializeWasm() must be awaited first!");
18443 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
18444 // debug statements here
18446 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18448 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
18449 if(!isWasmInitialized) {
18450 throw new Error("initializeWasm() must be awaited first!");
18452 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
18453 return nativeResponseValue;
18455 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18457 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18458 if(!isWasmInitialized) {
18459 throw new Error("initializeWasm() must be awaited first!");
18461 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
18462 // debug statements here
18464 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18466 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
18467 if(!isWasmInitialized) {
18468 throw new Error("initializeWasm() must be awaited first!");
18470 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
18471 return nativeResponseValue;
18473 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18475 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
18476 if(!isWasmInitialized) {
18477 throw new Error("initializeWasm() must be awaited first!");
18479 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
18480 // debug statements here
18482 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18484 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
18485 if(!isWasmInitialized) {
18486 throw new Error("initializeWasm() must be awaited first!");
18488 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
18489 return nativeResponseValue;
18491 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18493 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
18494 if(!isWasmInitialized) {
18495 throw new Error("initializeWasm() must be awaited first!");
18497 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
18498 // debug statements here
18500 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18502 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
18503 if(!isWasmInitialized) {
18504 throw new Error("initializeWasm() must be awaited first!");
18506 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
18507 return nativeResponseValue;
18509 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18511 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
18512 if(!isWasmInitialized) {
18513 throw new Error("initializeWasm() must be awaited first!");
18515 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
18516 // debug statements here
18518 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18520 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
18521 if(!isWasmInitialized) {
18522 throw new Error("initializeWasm() must be awaited first!");
18524 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
18525 return nativeResponseValue;
18527 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18529 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
18530 if(!isWasmInitialized) {
18531 throw new Error("initializeWasm() must be awaited first!");
18533 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
18534 // debug statements here
18536 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18538 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
18539 if(!isWasmInitialized) {
18540 throw new Error("initializeWasm() must be awaited first!");
18542 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
18543 return nativeResponseValue;
18545 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18547 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
18548 if(!isWasmInitialized) {
18549 throw new Error("initializeWasm() must be awaited first!");
18551 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
18552 // debug statements here
18554 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18556 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
18557 if(!isWasmInitialized) {
18558 throw new Error("initializeWasm() must be awaited first!");
18560 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
18561 return nativeResponseValue;
18563 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
18565 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
18566 if(!isWasmInitialized) {
18567 throw new Error("initializeWasm() must be awaited first!");
18569 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
18570 // debug statements here
18572 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18574 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
18575 if(!isWasmInitialized) {
18576 throw new Error("initializeWasm() must be awaited first!");
18578 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
18579 return nativeResponseValue;
18581 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
18583 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
18584 if(!isWasmInitialized) {
18585 throw new Error("initializeWasm() must be awaited first!");
18587 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
18588 // debug statements here
18590 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18592 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
18593 if(!isWasmInitialized) {
18594 throw new Error("initializeWasm() must be awaited first!");
18596 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
18597 return nativeResponseValue;
18599 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18601 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
18602 if(!isWasmInitialized) {
18603 throw new Error("initializeWasm() must be awaited first!");
18605 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
18606 // debug statements here
18608 // bool ChannelDetails_get_is_funding_locked(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18610 export function ChannelDetails_get_is_funding_locked(this_ptr: number): boolean {
18611 if(!isWasmInitialized) {
18612 throw new Error("initializeWasm() must be awaited first!");
18614 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_funding_locked(this_ptr);
18615 return nativeResponseValue;
18617 // void ChannelDetails_set_is_funding_locked(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18619 export function ChannelDetails_set_is_funding_locked(this_ptr: number, val: boolean): void {
18620 if(!isWasmInitialized) {
18621 throw new Error("initializeWasm() must be awaited first!");
18623 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_funding_locked(this_ptr, val);
18624 // debug statements here
18626 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18628 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
18629 if(!isWasmInitialized) {
18630 throw new Error("initializeWasm() must be awaited first!");
18632 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
18633 return nativeResponseValue;
18635 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18637 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
18638 if(!isWasmInitialized) {
18639 throw new Error("initializeWasm() must be awaited first!");
18641 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
18642 // debug statements here
18644 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18646 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
18647 if(!isWasmInitialized) {
18648 throw new Error("initializeWasm() must be awaited first!");
18650 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
18651 return nativeResponseValue;
18653 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
18655 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
18656 if(!isWasmInitialized) {
18657 throw new Error("initializeWasm() must be awaited first!");
18659 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
18660 // debug statements here
18662 // 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 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 inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_funding_locked_arg, bool is_usable_arg, bool is_public_arg);
18664 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: number, funding_txo_arg: number, channel_type_arg: number, short_channel_id_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, inbound_capacity_msat_arg: bigint, confirmations_required_arg: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_funding_locked_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean): number {
18665 if(!isWasmInitialized) {
18666 throw new Error("initializeWasm() must be awaited first!");
18668 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
18669 return nativeResponseValue;
18671 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
18673 export function ChannelDetails_clone_ptr(arg: number): number {
18674 if(!isWasmInitialized) {
18675 throw new Error("initializeWasm() must be awaited first!");
18677 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
18678 return nativeResponseValue;
18680 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
18682 export function ChannelDetails_clone(orig: number): number {
18683 if(!isWasmInitialized) {
18684 throw new Error("initializeWasm() must be awaited first!");
18686 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
18687 return nativeResponseValue;
18689 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
18691 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
18692 if(!isWasmInitialized) {
18693 throw new Error("initializeWasm() must be awaited first!");
18695 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
18696 return nativeResponseValue;
18698 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
18700 export function PaymentSendFailure_free(this_ptr: number): void {
18701 if(!isWasmInitialized) {
18702 throw new Error("initializeWasm() must be awaited first!");
18704 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
18705 // debug statements here
18707 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
18709 export function PaymentSendFailure_clone_ptr(arg: number): number {
18710 if(!isWasmInitialized) {
18711 throw new Error("initializeWasm() must be awaited first!");
18713 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
18714 return nativeResponseValue;
18716 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
18718 export function PaymentSendFailure_clone(orig: number): number {
18719 if(!isWasmInitialized) {
18720 throw new Error("initializeWasm() must be awaited first!");
18722 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
18723 return nativeResponseValue;
18725 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
18727 export function PaymentSendFailure_parameter_error(a: number): number {
18728 if(!isWasmInitialized) {
18729 throw new Error("initializeWasm() must be awaited first!");
18731 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
18732 return nativeResponseValue;
18734 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
18736 export function PaymentSendFailure_path_parameter_error(a: number): number {
18737 if(!isWasmInitialized) {
18738 throw new Error("initializeWasm() must be awaited first!");
18740 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
18741 return nativeResponseValue;
18743 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
18745 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
18746 if(!isWasmInitialized) {
18747 throw new Error("initializeWasm() must be awaited first!");
18749 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
18750 return nativeResponseValue;
18752 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
18754 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
18755 if(!isWasmInitialized) {
18756 throw new Error("initializeWasm() must be awaited first!");
18758 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
18759 return nativeResponseValue;
18761 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
18763 export function PhantomRouteHints_free(this_obj: number): void {
18764 if(!isWasmInitialized) {
18765 throw new Error("initializeWasm() must be awaited first!");
18767 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
18768 // debug statements here
18770 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18772 export function PhantomRouteHints_get_channels(this_ptr: number): number {
18773 if(!isWasmInitialized) {
18774 throw new Error("initializeWasm() must be awaited first!");
18776 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
18777 return nativeResponseValue;
18779 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
18781 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
18782 if(!isWasmInitialized) {
18783 throw new Error("initializeWasm() must be awaited first!");
18785 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
18786 // debug statements here
18788 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18790 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
18791 if(!isWasmInitialized) {
18792 throw new Error("initializeWasm() must be awaited first!");
18794 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
18795 return nativeResponseValue;
18797 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
18799 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
18800 if(!isWasmInitialized) {
18801 throw new Error("initializeWasm() must be awaited first!");
18803 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
18804 // debug statements here
18806 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
18808 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
18809 if(!isWasmInitialized) {
18810 throw new Error("initializeWasm() must be awaited first!");
18812 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
18813 return nativeResponseValue;
18815 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18817 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
18818 if(!isWasmInitialized) {
18819 throw new Error("initializeWasm() must be awaited first!");
18821 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
18822 // debug statements here
18824 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
18826 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
18827 if(!isWasmInitialized) {
18828 throw new Error("initializeWasm() must be awaited first!");
18830 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
18831 return nativeResponseValue;
18833 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
18835 export function PhantomRouteHints_clone_ptr(arg: number): number {
18836 if(!isWasmInitialized) {
18837 throw new Error("initializeWasm() must be awaited first!");
18839 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
18840 return nativeResponseValue;
18842 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
18844 export function PhantomRouteHints_clone(orig: number): number {
18845 if(!isWasmInitialized) {
18846 throw new Error("initializeWasm() must be awaited first!");
18848 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
18849 return nativeResponseValue;
18851 // 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);
18853 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
18854 if(!isWasmInitialized) {
18855 throw new Error("initializeWasm() must be awaited first!");
18857 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
18858 return nativeResponseValue;
18860 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
18862 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
18863 if(!isWasmInitialized) {
18864 throw new Error("initializeWasm() must be awaited first!");
18866 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
18867 return nativeResponseValue;
18869 // 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);
18871 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 {
18872 if(!isWasmInitialized) {
18873 throw new Error("initializeWasm() must be awaited first!");
18875 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
18876 return nativeResponseValue;
18878 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18880 export function ChannelManager_list_channels(this_arg: number): number {
18881 if(!isWasmInitialized) {
18882 throw new Error("initializeWasm() must be awaited first!");
18884 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
18885 return nativeResponseValue;
18887 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18889 export function ChannelManager_list_usable_channels(this_arg: number): number {
18890 if(!isWasmInitialized) {
18891 throw new Error("initializeWasm() must be awaited first!");
18893 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
18894 return nativeResponseValue;
18896 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
18898 export function ChannelManager_close_channel(this_arg: number, channel_id: number): number {
18899 if(!isWasmInitialized) {
18900 throw new Error("initializeWasm() must be awaited first!");
18902 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id);
18903 return nativeResponseValue;
18905 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_target_feerate(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], uint32_t target_feerate_sats_per_1000_weight);
18907 export function ChannelManager_close_channel_with_target_feerate(this_arg: number, channel_id: number, target_feerate_sats_per_1000_weight: number): number {
18908 if(!isWasmInitialized) {
18909 throw new Error("initializeWasm() must be awaited first!");
18911 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, target_feerate_sats_per_1000_weight);
18912 return nativeResponseValue;
18914 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32]);
18916 export function ChannelManager_force_close_channel(this_arg: number, channel_id: number): number {
18917 if(!isWasmInitialized) {
18918 throw new Error("initializeWasm() must be awaited first!");
18920 const nativeResponseValue = wasm.TS_ChannelManager_force_close_channel(this_arg, channel_id);
18921 return nativeResponseValue;
18923 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
18925 export function ChannelManager_force_close_all_channels(this_arg: number): void {
18926 if(!isWasmInitialized) {
18927 throw new Error("initializeWasm() must be awaited first!");
18929 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
18930 // debug statements here
18932 // 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);
18934 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
18935 if(!isWasmInitialized) {
18936 throw new Error("initializeWasm() must be awaited first!");
18938 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
18939 return nativeResponseValue;
18941 // 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);
18943 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
18944 if(!isWasmInitialized) {
18945 throw new Error("initializeWasm() must be awaited first!");
18947 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
18948 return nativeResponseValue;
18950 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
18952 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
18953 if(!isWasmInitialized) {
18954 throw new Error("initializeWasm() must be awaited first!");
18956 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
18957 // debug statements here
18959 // 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);
18961 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
18962 if(!isWasmInitialized) {
18963 throw new Error("initializeWasm() must be awaited first!");
18965 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
18966 return nativeResponseValue;
18968 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKTransaction funding_transaction);
18970 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, funding_transaction: number): number {
18971 if(!isWasmInitialized) {
18972 throw new Error("initializeWasm() must be awaited first!");
18974 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, funding_transaction);
18975 return nativeResponseValue;
18977 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
18979 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
18980 if(!isWasmInitialized) {
18981 throw new Error("initializeWasm() must be awaited first!");
18983 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
18984 // debug statements here
18986 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
18988 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
18989 if(!isWasmInitialized) {
18990 throw new Error("initializeWasm() must be awaited first!");
18992 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
18993 // debug statements here
18995 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
18997 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
18998 if(!isWasmInitialized) {
18999 throw new Error("initializeWasm() must be awaited first!");
19001 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
19002 // debug statements here
19004 // MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
19006 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): boolean {
19007 if(!isWasmInitialized) {
19008 throw new Error("initializeWasm() must be awaited first!");
19010 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
19011 return nativeResponseValue;
19013 // MUST_USE_RES bool ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
19015 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): boolean {
19016 if(!isWasmInitialized) {
19017 throw new Error("initializeWasm() must be awaited first!");
19019 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
19020 return nativeResponseValue;
19022 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
19024 export function ChannelManager_get_our_node_id(this_arg: number): number {
19025 if(!isWasmInitialized) {
19026 throw new Error("initializeWasm() must be awaited first!");
19028 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
19029 return nativeResponseValue;
19031 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], uint64_t user_channel_id);
19033 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, user_channel_id: bigint): number {
19034 if(!isWasmInitialized) {
19035 throw new Error("initializeWasm() must be awaited first!");
19037 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, user_channel_id);
19038 return nativeResponseValue;
19040 // 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);
19042 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19043 if(!isWasmInitialized) {
19044 throw new Error("initializeWasm() must be awaited first!");
19046 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
19047 return nativeResponseValue;
19049 // 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);
19051 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19052 if(!isWasmInitialized) {
19053 throw new Error("initializeWasm() must be awaited first!");
19055 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
19056 return nativeResponseValue;
19058 // 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);
19060 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19061 if(!isWasmInitialized) {
19062 throw new Error("initializeWasm() must be awaited first!");
19064 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19065 return nativeResponseValue;
19067 // 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);
19069 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 {
19070 if(!isWasmInitialized) {
19071 throw new Error("initializeWasm() must be awaited first!");
19073 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19074 return nativeResponseValue;
19076 // 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);
19078 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
19079 if(!isWasmInitialized) {
19080 throw new Error("initializeWasm() must be awaited first!");
19082 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
19083 return nativeResponseValue;
19085 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
19087 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
19088 if(!isWasmInitialized) {
19089 throw new Error("initializeWasm() must be awaited first!");
19091 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
19092 return nativeResponseValue;
19094 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
19096 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
19097 if(!isWasmInitialized) {
19098 throw new Error("initializeWasm() must be awaited first!");
19100 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
19101 return nativeResponseValue;
19103 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19105 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
19106 if(!isWasmInitialized) {
19107 throw new Error("initializeWasm() must be awaited first!");
19109 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
19110 return nativeResponseValue;
19112 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19114 export function ChannelManager_as_EventsProvider(this_arg: number): number {
19115 if(!isWasmInitialized) {
19116 throw new Error("initializeWasm() must be awaited first!");
19118 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
19119 return nativeResponseValue;
19121 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
19123 export function ChannelManager_as_Listen(this_arg: number): number {
19124 if(!isWasmInitialized) {
19125 throw new Error("initializeWasm() must be awaited first!");
19127 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
19128 return nativeResponseValue;
19130 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
19132 export function ChannelManager_as_Confirm(this_arg: number): number {
19133 if(!isWasmInitialized) {
19134 throw new Error("initializeWasm() must be awaited first!");
19136 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
19137 return nativeResponseValue;
19139 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
19141 export function ChannelManager_await_persistable_update(this_arg: number): void {
19142 if(!isWasmInitialized) {
19143 throw new Error("initializeWasm() must be awaited first!");
19145 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
19146 // debug statements here
19148 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
19150 export function ChannelManager_current_best_block(this_arg: number): number {
19151 if(!isWasmInitialized) {
19152 throw new Error("initializeWasm() must be awaited first!");
19154 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
19155 return nativeResponseValue;
19157 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
19159 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
19160 if(!isWasmInitialized) {
19161 throw new Error("initializeWasm() must be awaited first!");
19163 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
19164 return nativeResponseValue;
19166 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
19168 export function CounterpartyForwardingInfo_write(obj: number): number {
19169 if(!isWasmInitialized) {
19170 throw new Error("initializeWasm() must be awaited first!");
19172 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
19173 return nativeResponseValue;
19175 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
19177 export function CounterpartyForwardingInfo_read(ser: number): number {
19178 if(!isWasmInitialized) {
19179 throw new Error("initializeWasm() must be awaited first!");
19181 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
19182 return nativeResponseValue;
19184 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
19186 export function ChannelCounterparty_write(obj: number): number {
19187 if(!isWasmInitialized) {
19188 throw new Error("initializeWasm() must be awaited first!");
19190 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
19191 return nativeResponseValue;
19193 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
19195 export function ChannelCounterparty_read(ser: number): number {
19196 if(!isWasmInitialized) {
19197 throw new Error("initializeWasm() must be awaited first!");
19199 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
19200 return nativeResponseValue;
19202 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
19204 export function ChannelDetails_write(obj: number): number {
19205 if(!isWasmInitialized) {
19206 throw new Error("initializeWasm() must be awaited first!");
19208 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
19209 return nativeResponseValue;
19211 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
19213 export function ChannelDetails_read(ser: number): number {
19214 if(!isWasmInitialized) {
19215 throw new Error("initializeWasm() must be awaited first!");
19217 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
19218 return nativeResponseValue;
19220 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
19222 export function PhantomRouteHints_write(obj: number): number {
19223 if(!isWasmInitialized) {
19224 throw new Error("initializeWasm() must be awaited first!");
19226 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
19227 return nativeResponseValue;
19229 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
19231 export function PhantomRouteHints_read(ser: number): number {
19232 if(!isWasmInitialized) {
19233 throw new Error("initializeWasm() must be awaited first!");
19235 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
19236 return nativeResponseValue;
19238 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
19240 export function ChannelManager_write(obj: number): number {
19241 if(!isWasmInitialized) {
19242 throw new Error("initializeWasm() must be awaited first!");
19244 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
19245 return nativeResponseValue;
19247 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
19249 export function ChannelManagerReadArgs_free(this_obj: number): void {
19250 if(!isWasmInitialized) {
19251 throw new Error("initializeWasm() must be awaited first!");
19253 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
19254 // debug statements here
19256 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19258 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
19259 if(!isWasmInitialized) {
19260 throw new Error("initializeWasm() must be awaited first!");
19262 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
19263 return nativeResponseValue;
19265 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
19267 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
19268 if(!isWasmInitialized) {
19269 throw new Error("initializeWasm() must be awaited first!");
19271 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
19272 // debug statements here
19274 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19276 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
19277 if(!isWasmInitialized) {
19278 throw new Error("initializeWasm() must be awaited first!");
19280 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
19281 return nativeResponseValue;
19283 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
19285 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
19286 if(!isWasmInitialized) {
19287 throw new Error("initializeWasm() must be awaited first!");
19289 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
19290 // debug statements here
19292 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19294 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
19295 if(!isWasmInitialized) {
19296 throw new Error("initializeWasm() must be awaited first!");
19298 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
19299 return nativeResponseValue;
19301 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
19303 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
19304 if(!isWasmInitialized) {
19305 throw new Error("initializeWasm() must be awaited first!");
19307 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
19308 // debug statements here
19310 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19312 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
19313 if(!isWasmInitialized) {
19314 throw new Error("initializeWasm() must be awaited first!");
19316 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
19317 return nativeResponseValue;
19319 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
19321 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
19322 if(!isWasmInitialized) {
19323 throw new Error("initializeWasm() must be awaited first!");
19325 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
19326 // debug statements here
19328 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19330 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
19331 if(!isWasmInitialized) {
19332 throw new Error("initializeWasm() must be awaited first!");
19334 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
19335 return nativeResponseValue;
19337 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
19339 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
19340 if(!isWasmInitialized) {
19341 throw new Error("initializeWasm() must be awaited first!");
19343 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
19344 // debug statements here
19346 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19348 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
19349 if(!isWasmInitialized) {
19350 throw new Error("initializeWasm() must be awaited first!");
19352 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
19353 return nativeResponseValue;
19355 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
19357 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
19358 if(!isWasmInitialized) {
19359 throw new Error("initializeWasm() must be awaited first!");
19361 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
19362 // debug statements here
19364 // 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);
19366 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 {
19367 if(!isWasmInitialized) {
19368 throw new Error("initializeWasm() must be awaited first!");
19370 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
19371 return nativeResponseValue;
19373 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
19375 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
19376 if(!isWasmInitialized) {
19377 throw new Error("initializeWasm() must be awaited first!");
19379 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
19380 return nativeResponseValue;
19382 // void DecodeError_free(struct LDKDecodeError this_obj);
19384 export function DecodeError_free(this_obj: number): void {
19385 if(!isWasmInitialized) {
19386 throw new Error("initializeWasm() must be awaited first!");
19388 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
19389 // debug statements here
19391 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
19393 export function DecodeError_clone_ptr(arg: number): number {
19394 if(!isWasmInitialized) {
19395 throw new Error("initializeWasm() must be awaited first!");
19397 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
19398 return nativeResponseValue;
19400 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
19402 export function DecodeError_clone(orig: number): number {
19403 if(!isWasmInitialized) {
19404 throw new Error("initializeWasm() must be awaited first!");
19406 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
19407 return nativeResponseValue;
19409 // void Init_free(struct LDKInit this_obj);
19411 export function Init_free(this_obj: number): void {
19412 if(!isWasmInitialized) {
19413 throw new Error("initializeWasm() must be awaited first!");
19415 const nativeResponseValue = wasm.TS_Init_free(this_obj);
19416 // debug statements here
19418 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
19420 export function Init_get_features(this_ptr: number): number {
19421 if(!isWasmInitialized) {
19422 throw new Error("initializeWasm() must be awaited first!");
19424 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
19425 return nativeResponseValue;
19427 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
19429 export function Init_set_features(this_ptr: number, val: number): void {
19430 if(!isWasmInitialized) {
19431 throw new Error("initializeWasm() must be awaited first!");
19433 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
19434 // debug statements here
19436 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
19438 export function Init_get_remote_network_address(this_ptr: number): number {
19439 if(!isWasmInitialized) {
19440 throw new Error("initializeWasm() must be awaited first!");
19442 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
19443 return nativeResponseValue;
19445 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
19447 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
19448 if(!isWasmInitialized) {
19449 throw new Error("initializeWasm() must be awaited first!");
19451 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
19452 // debug statements here
19454 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
19456 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
19457 if(!isWasmInitialized) {
19458 throw new Error("initializeWasm() must be awaited first!");
19460 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
19461 return nativeResponseValue;
19463 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
19465 export function Init_clone_ptr(arg: number): number {
19466 if(!isWasmInitialized) {
19467 throw new Error("initializeWasm() must be awaited first!");
19469 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
19470 return nativeResponseValue;
19472 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
19474 export function Init_clone(orig: number): number {
19475 if(!isWasmInitialized) {
19476 throw new Error("initializeWasm() must be awaited first!");
19478 const nativeResponseValue = wasm.TS_Init_clone(orig);
19479 return nativeResponseValue;
19481 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
19483 export function ErrorMessage_free(this_obj: number): void {
19484 if(!isWasmInitialized) {
19485 throw new Error("initializeWasm() must be awaited first!");
19487 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
19488 // debug statements here
19490 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
19492 export function ErrorMessage_get_channel_id(this_ptr: number): number {
19493 if(!isWasmInitialized) {
19494 throw new Error("initializeWasm() must be awaited first!");
19496 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
19497 return nativeResponseValue;
19499 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19501 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
19502 if(!isWasmInitialized) {
19503 throw new Error("initializeWasm() must be awaited first!");
19505 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
19506 // debug statements here
19508 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
19510 export function ErrorMessage_get_data(this_ptr: number): number {
19511 if(!isWasmInitialized) {
19512 throw new Error("initializeWasm() must be awaited first!");
19514 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
19515 return nativeResponseValue;
19517 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
19519 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
19520 if(!isWasmInitialized) {
19521 throw new Error("initializeWasm() must be awaited first!");
19523 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
19524 // debug statements here
19526 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
19528 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
19529 if(!isWasmInitialized) {
19530 throw new Error("initializeWasm() must be awaited first!");
19532 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
19533 return nativeResponseValue;
19535 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
19537 export function ErrorMessage_clone_ptr(arg: number): number {
19538 if(!isWasmInitialized) {
19539 throw new Error("initializeWasm() must be awaited first!");
19541 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
19542 return nativeResponseValue;
19544 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
19546 export function ErrorMessage_clone(orig: number): number {
19547 if(!isWasmInitialized) {
19548 throw new Error("initializeWasm() must be awaited first!");
19550 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
19551 return nativeResponseValue;
19553 // void WarningMessage_free(struct LDKWarningMessage this_obj);
19555 export function WarningMessage_free(this_obj: number): void {
19556 if(!isWasmInitialized) {
19557 throw new Error("initializeWasm() must be awaited first!");
19559 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
19560 // debug statements here
19562 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
19564 export function WarningMessage_get_channel_id(this_ptr: number): number {
19565 if(!isWasmInitialized) {
19566 throw new Error("initializeWasm() must be awaited first!");
19568 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
19569 return nativeResponseValue;
19571 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19573 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
19574 if(!isWasmInitialized) {
19575 throw new Error("initializeWasm() must be awaited first!");
19577 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
19578 // debug statements here
19580 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
19582 export function WarningMessage_get_data(this_ptr: number): number {
19583 if(!isWasmInitialized) {
19584 throw new Error("initializeWasm() must be awaited first!");
19586 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
19587 return nativeResponseValue;
19589 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
19591 export function WarningMessage_set_data(this_ptr: number, val: number): void {
19592 if(!isWasmInitialized) {
19593 throw new Error("initializeWasm() must be awaited first!");
19595 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
19596 // debug statements here
19598 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
19600 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
19601 if(!isWasmInitialized) {
19602 throw new Error("initializeWasm() must be awaited first!");
19604 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
19605 return nativeResponseValue;
19607 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
19609 export function WarningMessage_clone_ptr(arg: number): number {
19610 if(!isWasmInitialized) {
19611 throw new Error("initializeWasm() must be awaited first!");
19613 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
19614 return nativeResponseValue;
19616 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
19618 export function WarningMessage_clone(orig: number): number {
19619 if(!isWasmInitialized) {
19620 throw new Error("initializeWasm() must be awaited first!");
19622 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
19623 return nativeResponseValue;
19625 // void Ping_free(struct LDKPing this_obj);
19627 export function Ping_free(this_obj: number): void {
19628 if(!isWasmInitialized) {
19629 throw new Error("initializeWasm() must be awaited first!");
19631 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
19632 // debug statements here
19634 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
19636 export function Ping_get_ponglen(this_ptr: number): number {
19637 if(!isWasmInitialized) {
19638 throw new Error("initializeWasm() must be awaited first!");
19640 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
19641 return nativeResponseValue;
19643 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
19645 export function Ping_set_ponglen(this_ptr: number, val: number): void {
19646 if(!isWasmInitialized) {
19647 throw new Error("initializeWasm() must be awaited first!");
19649 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
19650 // debug statements here
19652 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
19654 export function Ping_get_byteslen(this_ptr: number): number {
19655 if(!isWasmInitialized) {
19656 throw new Error("initializeWasm() must be awaited first!");
19658 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
19659 return nativeResponseValue;
19661 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
19663 export function Ping_set_byteslen(this_ptr: number, val: number): void {
19664 if(!isWasmInitialized) {
19665 throw new Error("initializeWasm() must be awaited first!");
19667 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
19668 // debug statements here
19670 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
19672 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
19673 if(!isWasmInitialized) {
19674 throw new Error("initializeWasm() must be awaited first!");
19676 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
19677 return nativeResponseValue;
19679 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
19681 export function Ping_clone_ptr(arg: number): number {
19682 if(!isWasmInitialized) {
19683 throw new Error("initializeWasm() must be awaited first!");
19685 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
19686 return nativeResponseValue;
19688 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
19690 export function Ping_clone(orig: number): number {
19691 if(!isWasmInitialized) {
19692 throw new Error("initializeWasm() must be awaited first!");
19694 const nativeResponseValue = wasm.TS_Ping_clone(orig);
19695 return nativeResponseValue;
19697 // void Pong_free(struct LDKPong this_obj);
19699 export function Pong_free(this_obj: number): void {
19700 if(!isWasmInitialized) {
19701 throw new Error("initializeWasm() must be awaited first!");
19703 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
19704 // debug statements here
19706 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
19708 export function Pong_get_byteslen(this_ptr: number): number {
19709 if(!isWasmInitialized) {
19710 throw new Error("initializeWasm() must be awaited first!");
19712 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
19713 return nativeResponseValue;
19715 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
19717 export function Pong_set_byteslen(this_ptr: number, val: number): void {
19718 if(!isWasmInitialized) {
19719 throw new Error("initializeWasm() must be awaited first!");
19721 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
19722 // debug statements here
19724 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
19726 export function Pong_new(byteslen_arg: number): number {
19727 if(!isWasmInitialized) {
19728 throw new Error("initializeWasm() must be awaited first!");
19730 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
19731 return nativeResponseValue;
19733 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
19735 export function Pong_clone_ptr(arg: number): number {
19736 if(!isWasmInitialized) {
19737 throw new Error("initializeWasm() must be awaited first!");
19739 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
19740 return nativeResponseValue;
19742 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
19744 export function Pong_clone(orig: number): number {
19745 if(!isWasmInitialized) {
19746 throw new Error("initializeWasm() must be awaited first!");
19748 const nativeResponseValue = wasm.TS_Pong_clone(orig);
19749 return nativeResponseValue;
19751 // void OpenChannel_free(struct LDKOpenChannel this_obj);
19753 export function OpenChannel_free(this_obj: number): void {
19754 if(!isWasmInitialized) {
19755 throw new Error("initializeWasm() must be awaited first!");
19757 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
19758 // debug statements here
19760 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
19762 export function OpenChannel_get_chain_hash(this_ptr: number): number {
19763 if(!isWasmInitialized) {
19764 throw new Error("initializeWasm() must be awaited first!");
19766 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
19767 return nativeResponseValue;
19769 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19771 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
19772 if(!isWasmInitialized) {
19773 throw new Error("initializeWasm() must be awaited first!");
19775 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
19776 // debug statements here
19778 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
19780 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
19781 if(!isWasmInitialized) {
19782 throw new Error("initializeWasm() must be awaited first!");
19784 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
19785 return nativeResponseValue;
19787 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19789 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
19790 if(!isWasmInitialized) {
19791 throw new Error("initializeWasm() must be awaited first!");
19793 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
19794 // debug statements here
19796 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19798 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
19799 if(!isWasmInitialized) {
19800 throw new Error("initializeWasm() must be awaited first!");
19802 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
19803 return nativeResponseValue;
19805 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19807 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
19808 if(!isWasmInitialized) {
19809 throw new Error("initializeWasm() must be awaited first!");
19811 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
19812 // debug statements here
19814 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19816 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
19817 if(!isWasmInitialized) {
19818 throw new Error("initializeWasm() must be awaited first!");
19820 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
19821 return nativeResponseValue;
19823 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19825 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
19826 if(!isWasmInitialized) {
19827 throw new Error("initializeWasm() must be awaited first!");
19829 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
19830 // debug statements here
19832 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19834 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
19835 if(!isWasmInitialized) {
19836 throw new Error("initializeWasm() must be awaited first!");
19838 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
19839 return nativeResponseValue;
19841 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19843 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
19844 if(!isWasmInitialized) {
19845 throw new Error("initializeWasm() must be awaited first!");
19847 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
19848 // debug statements here
19850 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19852 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
19853 if(!isWasmInitialized) {
19854 throw new Error("initializeWasm() must be awaited first!");
19856 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
19857 return nativeResponseValue;
19859 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19861 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
19862 if(!isWasmInitialized) {
19863 throw new Error("initializeWasm() must be awaited first!");
19865 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
19866 // debug statements here
19868 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19870 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
19871 if(!isWasmInitialized) {
19872 throw new Error("initializeWasm() must be awaited first!");
19874 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
19875 return nativeResponseValue;
19877 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19879 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
19880 if(!isWasmInitialized) {
19881 throw new Error("initializeWasm() must be awaited first!");
19883 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
19884 // debug statements here
19886 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19888 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
19889 if(!isWasmInitialized) {
19890 throw new Error("initializeWasm() must be awaited first!");
19892 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
19893 return nativeResponseValue;
19895 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
19897 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
19898 if(!isWasmInitialized) {
19899 throw new Error("initializeWasm() must be awaited first!");
19901 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
19902 // debug statements here
19904 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19906 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
19907 if(!isWasmInitialized) {
19908 throw new Error("initializeWasm() must be awaited first!");
19910 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
19911 return nativeResponseValue;
19913 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
19915 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
19916 if(!isWasmInitialized) {
19917 throw new Error("initializeWasm() must be awaited first!");
19919 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
19920 // debug statements here
19922 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19924 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
19925 if(!isWasmInitialized) {
19926 throw new Error("initializeWasm() must be awaited first!");
19928 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
19929 return nativeResponseValue;
19931 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
19933 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
19934 if(!isWasmInitialized) {
19935 throw new Error("initializeWasm() must be awaited first!");
19937 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
19938 // debug statements here
19940 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19942 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
19943 if(!isWasmInitialized) {
19944 throw new Error("initializeWasm() must be awaited first!");
19946 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
19947 return nativeResponseValue;
19949 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
19951 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
19952 if(!isWasmInitialized) {
19953 throw new Error("initializeWasm() must be awaited first!");
19955 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
19956 // debug statements here
19958 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19960 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
19961 if(!isWasmInitialized) {
19962 throw new Error("initializeWasm() must be awaited first!");
19964 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
19965 return nativeResponseValue;
19967 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19969 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
19970 if(!isWasmInitialized) {
19971 throw new Error("initializeWasm() must be awaited first!");
19973 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
19974 // debug statements here
19976 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19978 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
19979 if(!isWasmInitialized) {
19980 throw new Error("initializeWasm() must be awaited first!");
19982 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
19983 return nativeResponseValue;
19985 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19987 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
19988 if(!isWasmInitialized) {
19989 throw new Error("initializeWasm() must be awaited first!");
19991 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
19992 // debug statements here
19994 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
19996 export function OpenChannel_get_payment_point(this_ptr: number): number {
19997 if(!isWasmInitialized) {
19998 throw new Error("initializeWasm() must be awaited first!");
20000 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
20001 return nativeResponseValue;
20003 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20005 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
20006 if(!isWasmInitialized) {
20007 throw new Error("initializeWasm() must be awaited first!");
20009 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
20010 // debug statements here
20012 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20014 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20015 if(!isWasmInitialized) {
20016 throw new Error("initializeWasm() must be awaited first!");
20018 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
20019 return nativeResponseValue;
20021 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20023 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20024 if(!isWasmInitialized) {
20025 throw new Error("initializeWasm() must be awaited first!");
20027 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
20028 // debug statements here
20030 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20032 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
20033 if(!isWasmInitialized) {
20034 throw new Error("initializeWasm() must be awaited first!");
20036 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
20037 return nativeResponseValue;
20039 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20041 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20042 if(!isWasmInitialized) {
20043 throw new Error("initializeWasm() must be awaited first!");
20045 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
20046 // debug statements here
20048 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20050 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
20051 if(!isWasmInitialized) {
20052 throw new Error("initializeWasm() must be awaited first!");
20054 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
20055 return nativeResponseValue;
20057 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20059 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20060 if(!isWasmInitialized) {
20061 throw new Error("initializeWasm() must be awaited first!");
20063 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
20064 // debug statements here
20066 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20068 export function OpenChannel_get_channel_flags(this_ptr: number): number {
20069 if(!isWasmInitialized) {
20070 throw new Error("initializeWasm() must be awaited first!");
20072 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
20073 return nativeResponseValue;
20075 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
20077 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
20078 if(!isWasmInitialized) {
20079 throw new Error("initializeWasm() must be awaited first!");
20081 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
20082 // debug statements here
20084 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20086 export function OpenChannel_get_channel_type(this_ptr: number): number {
20087 if(!isWasmInitialized) {
20088 throw new Error("initializeWasm() must be awaited first!");
20090 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
20091 return nativeResponseValue;
20093 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20095 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
20096 if(!isWasmInitialized) {
20097 throw new Error("initializeWasm() must be awaited first!");
20099 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
20100 // debug statements here
20102 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
20104 export function OpenChannel_clone_ptr(arg: number): number {
20105 if(!isWasmInitialized) {
20106 throw new Error("initializeWasm() must be awaited first!");
20108 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
20109 return nativeResponseValue;
20111 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
20113 export function OpenChannel_clone(orig: number): number {
20114 if(!isWasmInitialized) {
20115 throw new Error("initializeWasm() must be awaited first!");
20117 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
20118 return nativeResponseValue;
20120 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
20122 export function AcceptChannel_free(this_obj: number): void {
20123 if(!isWasmInitialized) {
20124 throw new Error("initializeWasm() must be awaited first!");
20126 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
20127 // debug statements here
20129 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
20131 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
20132 if(!isWasmInitialized) {
20133 throw new Error("initializeWasm() must be awaited first!");
20135 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
20136 return nativeResponseValue;
20138 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20140 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20141 if(!isWasmInitialized) {
20142 throw new Error("initializeWasm() must be awaited first!");
20144 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
20145 // debug statements here
20147 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20149 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20150 if(!isWasmInitialized) {
20151 throw new Error("initializeWasm() must be awaited first!");
20153 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
20154 return nativeResponseValue;
20156 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20158 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20159 if(!isWasmInitialized) {
20160 throw new Error("initializeWasm() must be awaited first!");
20162 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
20163 // debug statements here
20165 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20167 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20168 if(!isWasmInitialized) {
20169 throw new Error("initializeWasm() must be awaited first!");
20171 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20172 return nativeResponseValue;
20174 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20176 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20177 if(!isWasmInitialized) {
20178 throw new Error("initializeWasm() must be awaited first!");
20180 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20181 // debug statements here
20183 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20185 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20186 if(!isWasmInitialized) {
20187 throw new Error("initializeWasm() must be awaited first!");
20189 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
20190 return nativeResponseValue;
20192 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20194 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20195 if(!isWasmInitialized) {
20196 throw new Error("initializeWasm() must be awaited first!");
20198 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
20199 // debug statements here
20201 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20203 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20204 if(!isWasmInitialized) {
20205 throw new Error("initializeWasm() must be awaited first!");
20207 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
20208 return nativeResponseValue;
20210 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20212 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20213 if(!isWasmInitialized) {
20214 throw new Error("initializeWasm() must be awaited first!");
20216 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
20217 // debug statements here
20219 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20221 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
20222 if(!isWasmInitialized) {
20223 throw new Error("initializeWasm() must be awaited first!");
20225 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
20226 return nativeResponseValue;
20228 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
20230 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
20231 if(!isWasmInitialized) {
20232 throw new Error("initializeWasm() must be awaited first!");
20234 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
20235 // debug statements here
20237 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20239 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
20240 if(!isWasmInitialized) {
20241 throw new Error("initializeWasm() must be awaited first!");
20243 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
20244 return nativeResponseValue;
20246 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20248 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
20249 if(!isWasmInitialized) {
20250 throw new Error("initializeWasm() must be awaited first!");
20252 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
20253 // debug statements here
20255 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20257 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
20258 if(!isWasmInitialized) {
20259 throw new Error("initializeWasm() must be awaited first!");
20261 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
20262 return nativeResponseValue;
20264 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20266 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20267 if(!isWasmInitialized) {
20268 throw new Error("initializeWasm() must be awaited first!");
20270 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
20271 // debug statements here
20273 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20275 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
20276 if(!isWasmInitialized) {
20277 throw new Error("initializeWasm() must be awaited first!");
20279 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
20280 return nativeResponseValue;
20282 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20284 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20285 if(!isWasmInitialized) {
20286 throw new Error("initializeWasm() must be awaited first!");
20288 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
20289 // debug statements here
20291 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20293 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
20294 if(!isWasmInitialized) {
20295 throw new Error("initializeWasm() must be awaited first!");
20297 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
20298 return nativeResponseValue;
20300 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20302 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20303 if(!isWasmInitialized) {
20304 throw new Error("initializeWasm() must be awaited first!");
20306 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
20307 // debug statements here
20309 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20311 export function AcceptChannel_get_payment_point(this_ptr: number): number {
20312 if(!isWasmInitialized) {
20313 throw new Error("initializeWasm() must be awaited first!");
20315 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
20316 return nativeResponseValue;
20318 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20320 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
20321 if(!isWasmInitialized) {
20322 throw new Error("initializeWasm() must be awaited first!");
20324 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
20325 // debug statements here
20327 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20329 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20330 if(!isWasmInitialized) {
20331 throw new Error("initializeWasm() must be awaited first!");
20333 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
20334 return nativeResponseValue;
20336 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20338 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20339 if(!isWasmInitialized) {
20340 throw new Error("initializeWasm() must be awaited first!");
20342 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
20343 // debug statements here
20345 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20347 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
20348 if(!isWasmInitialized) {
20349 throw new Error("initializeWasm() must be awaited first!");
20351 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
20352 return nativeResponseValue;
20354 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20356 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20357 if(!isWasmInitialized) {
20358 throw new Error("initializeWasm() must be awaited first!");
20360 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
20361 // debug statements here
20363 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20365 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
20366 if(!isWasmInitialized) {
20367 throw new Error("initializeWasm() must be awaited first!");
20369 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
20370 return nativeResponseValue;
20372 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20374 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20375 if(!isWasmInitialized) {
20376 throw new Error("initializeWasm() must be awaited first!");
20378 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
20379 // debug statements here
20381 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20383 export function AcceptChannel_get_channel_type(this_ptr: number): number {
20384 if(!isWasmInitialized) {
20385 throw new Error("initializeWasm() must be awaited first!");
20387 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
20388 return nativeResponseValue;
20390 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20392 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
20393 if(!isWasmInitialized) {
20394 throw new Error("initializeWasm() must be awaited first!");
20396 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
20397 // debug statements here
20399 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
20401 export function AcceptChannel_clone_ptr(arg: number): number {
20402 if(!isWasmInitialized) {
20403 throw new Error("initializeWasm() must be awaited first!");
20405 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
20406 return nativeResponseValue;
20408 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
20410 export function AcceptChannel_clone(orig: number): number {
20411 if(!isWasmInitialized) {
20412 throw new Error("initializeWasm() must be awaited first!");
20414 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
20415 return nativeResponseValue;
20417 // void FundingCreated_free(struct LDKFundingCreated this_obj);
20419 export function FundingCreated_free(this_obj: number): void {
20420 if(!isWasmInitialized) {
20421 throw new Error("initializeWasm() must be awaited first!");
20423 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
20424 // debug statements here
20426 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
20428 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
20429 if(!isWasmInitialized) {
20430 throw new Error("initializeWasm() must be awaited first!");
20432 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
20433 return nativeResponseValue;
20435 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20437 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
20438 if(!isWasmInitialized) {
20439 throw new Error("initializeWasm() must be awaited first!");
20441 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
20442 // debug statements here
20444 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
20446 export function FundingCreated_get_funding_txid(this_ptr: number): number {
20447 if(!isWasmInitialized) {
20448 throw new Error("initializeWasm() must be awaited first!");
20450 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
20451 return nativeResponseValue;
20453 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20455 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
20456 if(!isWasmInitialized) {
20457 throw new Error("initializeWasm() must be awaited first!");
20459 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
20460 // debug statements here
20462 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
20464 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
20465 if(!isWasmInitialized) {
20466 throw new Error("initializeWasm() must be awaited first!");
20468 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
20469 return nativeResponseValue;
20471 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
20473 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
20474 if(!isWasmInitialized) {
20475 throw new Error("initializeWasm() must be awaited first!");
20477 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
20478 // debug statements here
20480 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
20482 export function FundingCreated_get_signature(this_ptr: number): number {
20483 if(!isWasmInitialized) {
20484 throw new Error("initializeWasm() must be awaited first!");
20486 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
20487 return nativeResponseValue;
20489 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
20491 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
20492 if(!isWasmInitialized) {
20493 throw new Error("initializeWasm() must be awaited first!");
20495 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
20496 // debug statements here
20498 // 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);
20500 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
20501 if(!isWasmInitialized) {
20502 throw new Error("initializeWasm() must be awaited first!");
20504 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
20505 return nativeResponseValue;
20507 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
20509 export function FundingCreated_clone_ptr(arg: number): number {
20510 if(!isWasmInitialized) {
20511 throw new Error("initializeWasm() must be awaited first!");
20513 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
20514 return nativeResponseValue;
20516 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
20518 export function FundingCreated_clone(orig: number): number {
20519 if(!isWasmInitialized) {
20520 throw new Error("initializeWasm() must be awaited first!");
20522 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
20523 return nativeResponseValue;
20525 // void FundingSigned_free(struct LDKFundingSigned this_obj);
20527 export function FundingSigned_free(this_obj: number): void {
20528 if(!isWasmInitialized) {
20529 throw new Error("initializeWasm() must be awaited first!");
20531 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
20532 // debug statements here
20534 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
20536 export function FundingSigned_get_channel_id(this_ptr: number): number {
20537 if(!isWasmInitialized) {
20538 throw new Error("initializeWasm() must be awaited first!");
20540 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
20541 return nativeResponseValue;
20543 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20545 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
20546 if(!isWasmInitialized) {
20547 throw new Error("initializeWasm() must be awaited first!");
20549 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
20550 // debug statements here
20552 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
20554 export function FundingSigned_get_signature(this_ptr: number): number {
20555 if(!isWasmInitialized) {
20556 throw new Error("initializeWasm() must be awaited first!");
20558 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
20559 return nativeResponseValue;
20561 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
20563 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
20564 if(!isWasmInitialized) {
20565 throw new Error("initializeWasm() must be awaited first!");
20567 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
20568 // debug statements here
20570 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
20572 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
20573 if(!isWasmInitialized) {
20574 throw new Error("initializeWasm() must be awaited first!");
20576 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
20577 return nativeResponseValue;
20579 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
20581 export function FundingSigned_clone_ptr(arg: number): number {
20582 if(!isWasmInitialized) {
20583 throw new Error("initializeWasm() must be awaited first!");
20585 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
20586 return nativeResponseValue;
20588 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
20590 export function FundingSigned_clone(orig: number): number {
20591 if(!isWasmInitialized) {
20592 throw new Error("initializeWasm() must be awaited first!");
20594 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
20595 return nativeResponseValue;
20597 // void FundingLocked_free(struct LDKFundingLocked this_obj);
20599 export function FundingLocked_free(this_obj: number): void {
20600 if(!isWasmInitialized) {
20601 throw new Error("initializeWasm() must be awaited first!");
20603 const nativeResponseValue = wasm.TS_FundingLocked_free(this_obj);
20604 // debug statements here
20606 // const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
20608 export function FundingLocked_get_channel_id(this_ptr: number): number {
20609 if(!isWasmInitialized) {
20610 throw new Error("initializeWasm() must be awaited first!");
20612 const nativeResponseValue = wasm.TS_FundingLocked_get_channel_id(this_ptr);
20613 return nativeResponseValue;
20615 // void FundingLocked_set_channel_id(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20617 export function FundingLocked_set_channel_id(this_ptr: number, val: number): void {
20618 if(!isWasmInitialized) {
20619 throw new Error("initializeWasm() must be awaited first!");
20621 const nativeResponseValue = wasm.TS_FundingLocked_set_channel_id(this_ptr, val);
20622 // debug statements here
20624 // struct LDKPublicKey FundingLocked_get_next_per_commitment_point(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
20626 export function FundingLocked_get_next_per_commitment_point(this_ptr: number): number {
20627 if(!isWasmInitialized) {
20628 throw new Error("initializeWasm() must be awaited first!");
20630 const nativeResponseValue = wasm.TS_FundingLocked_get_next_per_commitment_point(this_ptr);
20631 return nativeResponseValue;
20633 // void FundingLocked_set_next_per_commitment_point(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20635 export function FundingLocked_set_next_per_commitment_point(this_ptr: number, val: number): void {
20636 if(!isWasmInitialized) {
20637 throw new Error("initializeWasm() must be awaited first!");
20639 const nativeResponseValue = wasm.TS_FundingLocked_set_next_per_commitment_point(this_ptr, val);
20640 // debug statements here
20642 // struct LDKCOption_u64Z FundingLocked_get_short_channel_id_alias(const struct LDKFundingLocked *NONNULL_PTR this_ptr);
20644 export function FundingLocked_get_short_channel_id_alias(this_ptr: number): number {
20645 if(!isWasmInitialized) {
20646 throw new Error("initializeWasm() must be awaited first!");
20648 const nativeResponseValue = wasm.TS_FundingLocked_get_short_channel_id_alias(this_ptr);
20649 return nativeResponseValue;
20651 // void FundingLocked_set_short_channel_id_alias(struct LDKFundingLocked *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
20653 export function FundingLocked_set_short_channel_id_alias(this_ptr: number, val: number): void {
20654 if(!isWasmInitialized) {
20655 throw new Error("initializeWasm() must be awaited first!");
20657 const nativeResponseValue = wasm.TS_FundingLocked_set_short_channel_id_alias(this_ptr, val);
20658 // debug statements here
20660 // MUST_USE_RES struct LDKFundingLocked FundingLocked_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKPublicKey next_per_commitment_point_arg, struct LDKCOption_u64Z short_channel_id_alias_arg);
20662 export function FundingLocked_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
20663 if(!isWasmInitialized) {
20664 throw new Error("initializeWasm() must be awaited first!");
20666 const nativeResponseValue = wasm.TS_FundingLocked_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
20667 return nativeResponseValue;
20669 // uintptr_t FundingLocked_clone_ptr(LDKFundingLocked *NONNULL_PTR arg);
20671 export function FundingLocked_clone_ptr(arg: number): number {
20672 if(!isWasmInitialized) {
20673 throw new Error("initializeWasm() must be awaited first!");
20675 const nativeResponseValue = wasm.TS_FundingLocked_clone_ptr(arg);
20676 return nativeResponseValue;
20678 // struct LDKFundingLocked FundingLocked_clone(const struct LDKFundingLocked *NONNULL_PTR orig);
20680 export function FundingLocked_clone(orig: number): number {
20681 if(!isWasmInitialized) {
20682 throw new Error("initializeWasm() must be awaited first!");
20684 const nativeResponseValue = wasm.TS_FundingLocked_clone(orig);
20685 return nativeResponseValue;
20687 // void Shutdown_free(struct LDKShutdown this_obj);
20689 export function Shutdown_free(this_obj: number): void {
20690 if(!isWasmInitialized) {
20691 throw new Error("initializeWasm() must be awaited first!");
20693 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
20694 // debug statements here
20696 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
20698 export function Shutdown_get_channel_id(this_ptr: number): number {
20699 if(!isWasmInitialized) {
20700 throw new Error("initializeWasm() must be awaited first!");
20702 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
20703 return nativeResponseValue;
20705 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20707 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
20708 if(!isWasmInitialized) {
20709 throw new Error("initializeWasm() must be awaited first!");
20711 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
20712 // debug statements here
20714 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
20716 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
20717 if(!isWasmInitialized) {
20718 throw new Error("initializeWasm() must be awaited first!");
20720 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
20721 return nativeResponseValue;
20723 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
20725 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
20726 if(!isWasmInitialized) {
20727 throw new Error("initializeWasm() must be awaited first!");
20729 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
20730 // debug statements here
20732 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
20734 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
20735 if(!isWasmInitialized) {
20736 throw new Error("initializeWasm() must be awaited first!");
20738 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
20739 return nativeResponseValue;
20741 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
20743 export function Shutdown_clone_ptr(arg: number): number {
20744 if(!isWasmInitialized) {
20745 throw new Error("initializeWasm() must be awaited first!");
20747 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
20748 return nativeResponseValue;
20750 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
20752 export function Shutdown_clone(orig: number): number {
20753 if(!isWasmInitialized) {
20754 throw new Error("initializeWasm() must be awaited first!");
20756 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
20757 return nativeResponseValue;
20759 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
20761 export function ClosingSignedFeeRange_free(this_obj: number): void {
20762 if(!isWasmInitialized) {
20763 throw new Error("initializeWasm() must be awaited first!");
20765 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
20766 // debug statements here
20768 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
20770 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
20771 if(!isWasmInitialized) {
20772 throw new Error("initializeWasm() must be awaited first!");
20774 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
20775 return nativeResponseValue;
20777 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
20779 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
20780 if(!isWasmInitialized) {
20781 throw new Error("initializeWasm() must be awaited first!");
20783 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
20784 // debug statements here
20786 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
20788 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
20789 if(!isWasmInitialized) {
20790 throw new Error("initializeWasm() must be awaited first!");
20792 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
20793 return nativeResponseValue;
20795 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
20797 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
20798 if(!isWasmInitialized) {
20799 throw new Error("initializeWasm() must be awaited first!");
20801 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
20802 // debug statements here
20804 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
20806 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
20807 if(!isWasmInitialized) {
20808 throw new Error("initializeWasm() must be awaited first!");
20810 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
20811 return nativeResponseValue;
20813 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
20815 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
20816 if(!isWasmInitialized) {
20817 throw new Error("initializeWasm() must be awaited first!");
20819 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
20820 return nativeResponseValue;
20822 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
20824 export function ClosingSignedFeeRange_clone(orig: number): number {
20825 if(!isWasmInitialized) {
20826 throw new Error("initializeWasm() must be awaited first!");
20828 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
20829 return nativeResponseValue;
20831 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
20833 export function ClosingSigned_free(this_obj: number): void {
20834 if(!isWasmInitialized) {
20835 throw new Error("initializeWasm() must be awaited first!");
20837 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
20838 // debug statements here
20840 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
20842 export function ClosingSigned_get_channel_id(this_ptr: number): number {
20843 if(!isWasmInitialized) {
20844 throw new Error("initializeWasm() must be awaited first!");
20846 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
20847 return nativeResponseValue;
20849 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20851 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
20852 if(!isWasmInitialized) {
20853 throw new Error("initializeWasm() must be awaited first!");
20855 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
20856 // debug statements here
20858 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20860 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
20861 if(!isWasmInitialized) {
20862 throw new Error("initializeWasm() must be awaited first!");
20864 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
20865 return nativeResponseValue;
20867 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
20869 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
20870 if(!isWasmInitialized) {
20871 throw new Error("initializeWasm() must be awaited first!");
20873 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
20874 // debug statements here
20876 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20878 export function ClosingSigned_get_signature(this_ptr: number): number {
20879 if(!isWasmInitialized) {
20880 throw new Error("initializeWasm() must be awaited first!");
20882 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
20883 return nativeResponseValue;
20885 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
20887 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
20888 if(!isWasmInitialized) {
20889 throw new Error("initializeWasm() must be awaited first!");
20891 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
20892 // debug statements here
20894 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
20896 export function ClosingSigned_get_fee_range(this_ptr: number): number {
20897 if(!isWasmInitialized) {
20898 throw new Error("initializeWasm() must be awaited first!");
20900 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
20901 return nativeResponseValue;
20903 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
20905 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
20906 if(!isWasmInitialized) {
20907 throw new Error("initializeWasm() must be awaited first!");
20909 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
20910 // debug statements here
20912 // 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);
20914 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
20915 if(!isWasmInitialized) {
20916 throw new Error("initializeWasm() must be awaited first!");
20918 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
20919 return nativeResponseValue;
20921 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
20923 export function ClosingSigned_clone_ptr(arg: number): number {
20924 if(!isWasmInitialized) {
20925 throw new Error("initializeWasm() must be awaited first!");
20927 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
20928 return nativeResponseValue;
20930 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
20932 export function ClosingSigned_clone(orig: number): number {
20933 if(!isWasmInitialized) {
20934 throw new Error("initializeWasm() must be awaited first!");
20936 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
20937 return nativeResponseValue;
20939 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
20941 export function UpdateAddHTLC_free(this_obj: number): void {
20942 if(!isWasmInitialized) {
20943 throw new Error("initializeWasm() must be awaited first!");
20945 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
20946 // debug statements here
20948 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
20950 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
20951 if(!isWasmInitialized) {
20952 throw new Error("initializeWasm() must be awaited first!");
20954 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
20955 return nativeResponseValue;
20957 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20959 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
20960 if(!isWasmInitialized) {
20961 throw new Error("initializeWasm() must be awaited first!");
20963 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
20964 // debug statements here
20966 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20968 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
20969 if(!isWasmInitialized) {
20970 throw new Error("initializeWasm() must be awaited first!");
20972 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
20973 return nativeResponseValue;
20975 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
20977 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
20978 if(!isWasmInitialized) {
20979 throw new Error("initializeWasm() must be awaited first!");
20981 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
20982 // debug statements here
20984 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
20986 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
20987 if(!isWasmInitialized) {
20988 throw new Error("initializeWasm() must be awaited first!");
20990 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
20991 return nativeResponseValue;
20993 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
20995 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
20996 if(!isWasmInitialized) {
20997 throw new Error("initializeWasm() must be awaited first!");
20999 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
21000 // debug statements here
21002 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21004 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
21005 if(!isWasmInitialized) {
21006 throw new Error("initializeWasm() must be awaited first!");
21008 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
21009 return nativeResponseValue;
21011 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21013 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
21014 if(!isWasmInitialized) {
21015 throw new Error("initializeWasm() must be awaited first!");
21017 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
21018 // debug statements here
21020 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21022 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
21023 if(!isWasmInitialized) {
21024 throw new Error("initializeWasm() must be awaited first!");
21026 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
21027 return nativeResponseValue;
21029 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
21031 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
21032 if(!isWasmInitialized) {
21033 throw new Error("initializeWasm() must be awaited first!");
21035 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
21036 // debug statements here
21038 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
21040 export function UpdateAddHTLC_clone_ptr(arg: number): number {
21041 if(!isWasmInitialized) {
21042 throw new Error("initializeWasm() must be awaited first!");
21044 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
21045 return nativeResponseValue;
21047 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
21049 export function UpdateAddHTLC_clone(orig: number): number {
21050 if(!isWasmInitialized) {
21051 throw new Error("initializeWasm() must be awaited first!");
21053 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
21054 return nativeResponseValue;
21056 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
21058 export function UpdateFulfillHTLC_free(this_obj: number): void {
21059 if(!isWasmInitialized) {
21060 throw new Error("initializeWasm() must be awaited first!");
21062 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
21063 // debug statements here
21065 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21067 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
21068 if(!isWasmInitialized) {
21069 throw new Error("initializeWasm() must be awaited first!");
21071 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
21072 return nativeResponseValue;
21074 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21076 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
21077 if(!isWasmInitialized) {
21078 throw new Error("initializeWasm() must be awaited first!");
21080 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
21081 // debug statements here
21083 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
21085 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
21086 if(!isWasmInitialized) {
21087 throw new Error("initializeWasm() must be awaited first!");
21089 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
21090 return nativeResponseValue;
21092 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
21094 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21095 if(!isWasmInitialized) {
21096 throw new Error("initializeWasm() must be awaited first!");
21098 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
21099 // debug statements here
21101 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21103 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
21104 if(!isWasmInitialized) {
21105 throw new Error("initializeWasm() must be awaited first!");
21107 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
21108 return nativeResponseValue;
21110 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21112 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
21113 if(!isWasmInitialized) {
21114 throw new Error("initializeWasm() must be awaited first!");
21116 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
21117 // debug statements here
21119 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
21121 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
21122 if(!isWasmInitialized) {
21123 throw new Error("initializeWasm() must be awaited first!");
21125 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
21126 return nativeResponseValue;
21128 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
21130 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
21131 if(!isWasmInitialized) {
21132 throw new Error("initializeWasm() must be awaited first!");
21134 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
21135 return nativeResponseValue;
21137 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
21139 export function UpdateFulfillHTLC_clone(orig: number): number {
21140 if(!isWasmInitialized) {
21141 throw new Error("initializeWasm() must be awaited first!");
21143 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
21144 return nativeResponseValue;
21146 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
21148 export function UpdateFailHTLC_free(this_obj: number): void {
21149 if(!isWasmInitialized) {
21150 throw new Error("initializeWasm() must be awaited first!");
21152 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
21153 // debug statements here
21155 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
21157 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
21158 if(!isWasmInitialized) {
21159 throw new Error("initializeWasm() must be awaited first!");
21161 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
21162 return nativeResponseValue;
21164 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21166 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
21167 if(!isWasmInitialized) {
21168 throw new Error("initializeWasm() must be awaited first!");
21170 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
21171 // debug statements here
21173 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
21175 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
21176 if(!isWasmInitialized) {
21177 throw new Error("initializeWasm() must be awaited first!");
21179 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
21180 return nativeResponseValue;
21182 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
21184 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21185 if(!isWasmInitialized) {
21186 throw new Error("initializeWasm() must be awaited first!");
21188 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
21189 // debug statements here
21191 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
21193 export function UpdateFailHTLC_clone_ptr(arg: number): number {
21194 if(!isWasmInitialized) {
21195 throw new Error("initializeWasm() must be awaited first!");
21197 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
21198 return nativeResponseValue;
21200 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
21202 export function UpdateFailHTLC_clone(orig: number): number {
21203 if(!isWasmInitialized) {
21204 throw new Error("initializeWasm() must be awaited first!");
21206 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
21207 return nativeResponseValue;
21209 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
21211 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
21212 if(!isWasmInitialized) {
21213 throw new Error("initializeWasm() must be awaited first!");
21215 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
21216 // debug statements here
21218 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
21220 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
21221 if(!isWasmInitialized) {
21222 throw new Error("initializeWasm() must be awaited first!");
21224 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
21225 return nativeResponseValue;
21227 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21229 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
21230 if(!isWasmInitialized) {
21231 throw new Error("initializeWasm() must be awaited first!");
21233 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
21234 // debug statements here
21236 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21238 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
21239 if(!isWasmInitialized) {
21240 throw new Error("initializeWasm() must be awaited first!");
21242 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
21243 return nativeResponseValue;
21245 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
21247 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21248 if(!isWasmInitialized) {
21249 throw new Error("initializeWasm() must be awaited first!");
21251 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
21252 // debug statements here
21254 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21256 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
21257 if(!isWasmInitialized) {
21258 throw new Error("initializeWasm() must be awaited first!");
21260 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
21261 return nativeResponseValue;
21263 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
21265 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
21266 if(!isWasmInitialized) {
21267 throw new Error("initializeWasm() must be awaited first!");
21269 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
21270 // debug statements here
21272 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
21274 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
21275 if(!isWasmInitialized) {
21276 throw new Error("initializeWasm() must be awaited first!");
21278 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
21279 return nativeResponseValue;
21281 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
21283 export function UpdateFailMalformedHTLC_clone(orig: number): number {
21284 if(!isWasmInitialized) {
21285 throw new Error("initializeWasm() must be awaited first!");
21287 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
21288 return nativeResponseValue;
21290 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
21292 export function CommitmentSigned_free(this_obj: number): void {
21293 if(!isWasmInitialized) {
21294 throw new Error("initializeWasm() must be awaited first!");
21296 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
21297 // debug statements here
21299 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
21301 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
21302 if(!isWasmInitialized) {
21303 throw new Error("initializeWasm() must be awaited first!");
21305 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
21306 return nativeResponseValue;
21308 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21310 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
21311 if(!isWasmInitialized) {
21312 throw new Error("initializeWasm() must be awaited first!");
21314 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
21315 // debug statements here
21317 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
21319 export function CommitmentSigned_get_signature(this_ptr: number): number {
21320 if(!isWasmInitialized) {
21321 throw new Error("initializeWasm() must be awaited first!");
21323 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
21324 return nativeResponseValue;
21326 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21328 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
21329 if(!isWasmInitialized) {
21330 throw new Error("initializeWasm() must be awaited first!");
21332 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
21333 // debug statements here
21335 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
21337 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
21338 if(!isWasmInitialized) {
21339 throw new Error("initializeWasm() must be awaited first!");
21341 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
21342 // debug statements here
21344 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
21346 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
21347 if(!isWasmInitialized) {
21348 throw new Error("initializeWasm() must be awaited first!");
21350 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
21351 return nativeResponseValue;
21353 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
21355 export function CommitmentSigned_clone_ptr(arg: number): number {
21356 if(!isWasmInitialized) {
21357 throw new Error("initializeWasm() must be awaited first!");
21359 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
21360 return nativeResponseValue;
21362 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
21364 export function CommitmentSigned_clone(orig: number): number {
21365 if(!isWasmInitialized) {
21366 throw new Error("initializeWasm() must be awaited first!");
21368 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
21369 return nativeResponseValue;
21371 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
21373 export function RevokeAndACK_free(this_obj: number): void {
21374 if(!isWasmInitialized) {
21375 throw new Error("initializeWasm() must be awaited first!");
21377 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
21378 // debug statements here
21380 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
21382 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
21383 if(!isWasmInitialized) {
21384 throw new Error("initializeWasm() must be awaited first!");
21386 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
21387 return nativeResponseValue;
21389 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21391 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
21392 if(!isWasmInitialized) {
21393 throw new Error("initializeWasm() must be awaited first!");
21395 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
21396 // debug statements here
21398 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
21400 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
21401 if(!isWasmInitialized) {
21402 throw new Error("initializeWasm() must be awaited first!");
21404 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
21405 return nativeResponseValue;
21407 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21409 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
21410 if(!isWasmInitialized) {
21411 throw new Error("initializeWasm() must be awaited first!");
21413 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
21414 // debug statements here
21416 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
21418 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
21419 if(!isWasmInitialized) {
21420 throw new Error("initializeWasm() must be awaited first!");
21422 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
21423 return nativeResponseValue;
21425 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21427 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
21428 if(!isWasmInitialized) {
21429 throw new Error("initializeWasm() must be awaited first!");
21431 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
21432 // debug statements here
21434 // 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);
21436 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
21437 if(!isWasmInitialized) {
21438 throw new Error("initializeWasm() must be awaited first!");
21440 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
21441 return nativeResponseValue;
21443 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
21445 export function RevokeAndACK_clone_ptr(arg: number): number {
21446 if(!isWasmInitialized) {
21447 throw new Error("initializeWasm() must be awaited first!");
21449 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
21450 return nativeResponseValue;
21452 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
21454 export function RevokeAndACK_clone(orig: number): number {
21455 if(!isWasmInitialized) {
21456 throw new Error("initializeWasm() must be awaited first!");
21458 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
21459 return nativeResponseValue;
21461 // void UpdateFee_free(struct LDKUpdateFee this_obj);
21463 export function UpdateFee_free(this_obj: number): void {
21464 if(!isWasmInitialized) {
21465 throw new Error("initializeWasm() must be awaited first!");
21467 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
21468 // debug statements here
21470 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
21472 export function UpdateFee_get_channel_id(this_ptr: number): number {
21473 if(!isWasmInitialized) {
21474 throw new Error("initializeWasm() must be awaited first!");
21476 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
21477 return nativeResponseValue;
21479 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21481 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
21482 if(!isWasmInitialized) {
21483 throw new Error("initializeWasm() must be awaited first!");
21485 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
21486 // debug statements here
21488 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
21490 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
21491 if(!isWasmInitialized) {
21492 throw new Error("initializeWasm() must be awaited first!");
21494 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
21495 return nativeResponseValue;
21497 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
21499 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
21500 if(!isWasmInitialized) {
21501 throw new Error("initializeWasm() must be awaited first!");
21503 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
21504 // debug statements here
21506 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
21508 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
21509 if(!isWasmInitialized) {
21510 throw new Error("initializeWasm() must be awaited first!");
21512 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
21513 return nativeResponseValue;
21515 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
21517 export function UpdateFee_clone_ptr(arg: number): number {
21518 if(!isWasmInitialized) {
21519 throw new Error("initializeWasm() must be awaited first!");
21521 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
21522 return nativeResponseValue;
21524 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
21526 export function UpdateFee_clone(orig: number): number {
21527 if(!isWasmInitialized) {
21528 throw new Error("initializeWasm() must be awaited first!");
21530 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
21531 return nativeResponseValue;
21533 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
21535 export function DataLossProtect_free(this_obj: number): void {
21536 if(!isWasmInitialized) {
21537 throw new Error("initializeWasm() must be awaited first!");
21539 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
21540 // debug statements here
21542 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
21544 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
21545 if(!isWasmInitialized) {
21546 throw new Error("initializeWasm() must be awaited first!");
21548 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
21549 return nativeResponseValue;
21551 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21553 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
21554 if(!isWasmInitialized) {
21555 throw new Error("initializeWasm() must be awaited first!");
21557 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
21558 // debug statements here
21560 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
21562 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
21563 if(!isWasmInitialized) {
21564 throw new Error("initializeWasm() must be awaited first!");
21566 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
21567 return nativeResponseValue;
21569 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21571 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
21572 if(!isWasmInitialized) {
21573 throw new Error("initializeWasm() must be awaited first!");
21575 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
21576 // debug statements here
21578 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
21580 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
21581 if(!isWasmInitialized) {
21582 throw new Error("initializeWasm() must be awaited first!");
21584 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
21585 return nativeResponseValue;
21587 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
21589 export function DataLossProtect_clone_ptr(arg: number): number {
21590 if(!isWasmInitialized) {
21591 throw new Error("initializeWasm() must be awaited first!");
21593 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
21594 return nativeResponseValue;
21596 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
21598 export function DataLossProtect_clone(orig: number): number {
21599 if(!isWasmInitialized) {
21600 throw new Error("initializeWasm() must be awaited first!");
21602 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
21603 return nativeResponseValue;
21605 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
21607 export function ChannelReestablish_free(this_obj: number): void {
21608 if(!isWasmInitialized) {
21609 throw new Error("initializeWasm() must be awaited first!");
21611 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
21612 // debug statements here
21614 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
21616 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
21617 if(!isWasmInitialized) {
21618 throw new Error("initializeWasm() must be awaited first!");
21620 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
21621 return nativeResponseValue;
21623 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21625 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
21626 if(!isWasmInitialized) {
21627 throw new Error("initializeWasm() must be awaited first!");
21629 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
21630 // debug statements here
21632 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
21634 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
21635 if(!isWasmInitialized) {
21636 throw new Error("initializeWasm() must be awaited first!");
21638 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
21639 return nativeResponseValue;
21641 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
21643 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
21644 if(!isWasmInitialized) {
21645 throw new Error("initializeWasm() must be awaited first!");
21647 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
21648 // debug statements here
21650 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
21652 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
21653 if(!isWasmInitialized) {
21654 throw new Error("initializeWasm() must be awaited first!");
21656 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
21657 return nativeResponseValue;
21659 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
21661 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
21662 if(!isWasmInitialized) {
21663 throw new Error("initializeWasm() must be awaited first!");
21665 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
21666 // debug statements here
21668 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
21670 export function ChannelReestablish_clone_ptr(arg: number): number {
21671 if(!isWasmInitialized) {
21672 throw new Error("initializeWasm() must be awaited first!");
21674 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
21675 return nativeResponseValue;
21677 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
21679 export function ChannelReestablish_clone(orig: number): number {
21680 if(!isWasmInitialized) {
21681 throw new Error("initializeWasm() must be awaited first!");
21683 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
21684 return nativeResponseValue;
21686 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
21688 export function AnnouncementSignatures_free(this_obj: number): void {
21689 if(!isWasmInitialized) {
21690 throw new Error("initializeWasm() must be awaited first!");
21692 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
21693 // debug statements here
21695 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
21697 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
21698 if(!isWasmInitialized) {
21699 throw new Error("initializeWasm() must be awaited first!");
21701 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
21702 return nativeResponseValue;
21704 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21706 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
21707 if(!isWasmInitialized) {
21708 throw new Error("initializeWasm() must be awaited first!");
21710 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
21711 // debug statements here
21713 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21715 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
21716 if(!isWasmInitialized) {
21717 throw new Error("initializeWasm() must be awaited first!");
21719 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
21720 return nativeResponseValue;
21722 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
21724 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
21725 if(!isWasmInitialized) {
21726 throw new Error("initializeWasm() must be awaited first!");
21728 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
21729 // debug statements here
21731 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21733 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
21734 if(!isWasmInitialized) {
21735 throw new Error("initializeWasm() must be awaited first!");
21737 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
21738 return nativeResponseValue;
21740 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
21742 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
21743 if(!isWasmInitialized) {
21744 throw new Error("initializeWasm() must be awaited first!");
21746 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
21747 // debug statements here
21749 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
21751 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
21752 if(!isWasmInitialized) {
21753 throw new Error("initializeWasm() must be awaited first!");
21755 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
21756 return nativeResponseValue;
21758 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
21760 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
21761 if(!isWasmInitialized) {
21762 throw new Error("initializeWasm() must be awaited first!");
21764 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
21765 // debug statements here
21767 // 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);
21769 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
21770 if(!isWasmInitialized) {
21771 throw new Error("initializeWasm() must be awaited first!");
21773 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
21774 return nativeResponseValue;
21776 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
21778 export function AnnouncementSignatures_clone_ptr(arg: number): number {
21779 if(!isWasmInitialized) {
21780 throw new Error("initializeWasm() must be awaited first!");
21782 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
21783 return nativeResponseValue;
21785 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
21787 export function AnnouncementSignatures_clone(orig: number): number {
21788 if(!isWasmInitialized) {
21789 throw new Error("initializeWasm() must be awaited first!");
21791 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
21792 return nativeResponseValue;
21794 // void NetAddress_free(struct LDKNetAddress this_ptr);
21796 export function NetAddress_free(this_ptr: number): void {
21797 if(!isWasmInitialized) {
21798 throw new Error("initializeWasm() must be awaited first!");
21800 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
21801 // debug statements here
21803 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
21805 export function NetAddress_clone_ptr(arg: number): number {
21806 if(!isWasmInitialized) {
21807 throw new Error("initializeWasm() must be awaited first!");
21809 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
21810 return nativeResponseValue;
21812 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
21814 export function NetAddress_clone(orig: number): number {
21815 if(!isWasmInitialized) {
21816 throw new Error("initializeWasm() must be awaited first!");
21818 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
21819 return nativeResponseValue;
21821 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
21823 export function NetAddress_ipv4(addr: number, port: number): number {
21824 if(!isWasmInitialized) {
21825 throw new Error("initializeWasm() must be awaited first!");
21827 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
21828 return nativeResponseValue;
21830 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
21832 export function NetAddress_ipv6(addr: number, port: number): number {
21833 if(!isWasmInitialized) {
21834 throw new Error("initializeWasm() must be awaited first!");
21836 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
21837 return nativeResponseValue;
21839 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
21841 export function NetAddress_onion_v2(a: number): number {
21842 if(!isWasmInitialized) {
21843 throw new Error("initializeWasm() must be awaited first!");
21845 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
21846 return nativeResponseValue;
21848 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
21850 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
21851 if(!isWasmInitialized) {
21852 throw new Error("initializeWasm() must be awaited first!");
21854 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
21855 return nativeResponseValue;
21857 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
21859 export function NetAddress_write(obj: number): number {
21860 if(!isWasmInitialized) {
21861 throw new Error("initializeWasm() must be awaited first!");
21863 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
21864 return nativeResponseValue;
21866 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
21868 export function NetAddress_read(ser: number): number {
21869 if(!isWasmInitialized) {
21870 throw new Error("initializeWasm() must be awaited first!");
21872 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
21873 return nativeResponseValue;
21875 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
21877 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
21878 if(!isWasmInitialized) {
21879 throw new Error("initializeWasm() must be awaited first!");
21881 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
21882 // debug statements here
21884 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21886 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
21887 if(!isWasmInitialized) {
21888 throw new Error("initializeWasm() must be awaited first!");
21890 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
21891 return nativeResponseValue;
21893 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
21895 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
21896 if(!isWasmInitialized) {
21897 throw new Error("initializeWasm() must be awaited first!");
21899 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
21900 // debug statements here
21902 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21904 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
21905 if(!isWasmInitialized) {
21906 throw new Error("initializeWasm() must be awaited first!");
21908 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
21909 return nativeResponseValue;
21911 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
21913 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
21914 if(!isWasmInitialized) {
21915 throw new Error("initializeWasm() must be awaited first!");
21917 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
21918 // debug statements here
21920 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
21922 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
21923 if(!isWasmInitialized) {
21924 throw new Error("initializeWasm() must be awaited first!");
21926 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
21927 return nativeResponseValue;
21929 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21931 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
21932 if(!isWasmInitialized) {
21933 throw new Error("initializeWasm() must be awaited first!");
21935 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
21936 // debug statements here
21938 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
21940 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
21941 if(!isWasmInitialized) {
21942 throw new Error("initializeWasm() must be awaited first!");
21944 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
21945 return nativeResponseValue;
21947 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
21949 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
21950 if(!isWasmInitialized) {
21951 throw new Error("initializeWasm() must be awaited first!");
21953 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
21954 // debug statements here
21956 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
21958 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
21959 if(!isWasmInitialized) {
21960 throw new Error("initializeWasm() must be awaited first!");
21962 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
21963 return nativeResponseValue;
21965 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21967 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
21968 if(!isWasmInitialized) {
21969 throw new Error("initializeWasm() must be awaited first!");
21971 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
21972 // debug statements here
21974 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
21976 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
21977 if(!isWasmInitialized) {
21978 throw new Error("initializeWasm() must be awaited first!");
21980 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
21981 // debug statements here
21983 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
21985 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
21986 if(!isWasmInitialized) {
21987 throw new Error("initializeWasm() must be awaited first!");
21989 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
21990 return nativeResponseValue;
21992 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
21994 export function UnsignedNodeAnnouncement_clone(orig: number): number {
21995 if(!isWasmInitialized) {
21996 throw new Error("initializeWasm() must be awaited first!");
21998 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
21999 return nativeResponseValue;
22001 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
22003 export function NodeAnnouncement_free(this_obj: number): void {
22004 if(!isWasmInitialized) {
22005 throw new Error("initializeWasm() must be awaited first!");
22007 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
22008 // debug statements here
22010 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22012 export function NodeAnnouncement_get_signature(this_ptr: number): number {
22013 if(!isWasmInitialized) {
22014 throw new Error("initializeWasm() must be awaited first!");
22016 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
22017 return nativeResponseValue;
22019 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22021 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
22022 if(!isWasmInitialized) {
22023 throw new Error("initializeWasm() must be awaited first!");
22025 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
22026 // debug statements here
22028 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22030 export function NodeAnnouncement_get_contents(this_ptr: number): number {
22031 if(!isWasmInitialized) {
22032 throw new Error("initializeWasm() must be awaited first!");
22034 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
22035 return nativeResponseValue;
22037 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
22039 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
22040 if(!isWasmInitialized) {
22041 throw new Error("initializeWasm() must be awaited first!");
22043 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
22044 // debug statements here
22046 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
22048 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
22049 if(!isWasmInitialized) {
22050 throw new Error("initializeWasm() must be awaited first!");
22052 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
22053 return nativeResponseValue;
22055 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
22057 export function NodeAnnouncement_clone_ptr(arg: number): number {
22058 if(!isWasmInitialized) {
22059 throw new Error("initializeWasm() must be awaited first!");
22061 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
22062 return nativeResponseValue;
22064 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
22066 export function NodeAnnouncement_clone(orig: number): number {
22067 if(!isWasmInitialized) {
22068 throw new Error("initializeWasm() must be awaited first!");
22070 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
22071 return nativeResponseValue;
22073 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
22075 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
22076 if(!isWasmInitialized) {
22077 throw new Error("initializeWasm() must be awaited first!");
22079 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
22080 // debug statements here
22082 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22084 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
22085 if(!isWasmInitialized) {
22086 throw new Error("initializeWasm() must be awaited first!");
22088 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
22089 return nativeResponseValue;
22091 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
22093 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
22094 if(!isWasmInitialized) {
22095 throw new Error("initializeWasm() must be awaited first!");
22097 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
22098 // debug statements here
22100 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
22102 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
22103 if(!isWasmInitialized) {
22104 throw new Error("initializeWasm() must be awaited first!");
22106 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
22107 return nativeResponseValue;
22109 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22111 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
22112 if(!isWasmInitialized) {
22113 throw new Error("initializeWasm() must be awaited first!");
22115 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
22116 // debug statements here
22118 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22120 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
22121 if(!isWasmInitialized) {
22122 throw new Error("initializeWasm() must be awaited first!");
22124 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
22125 return nativeResponseValue;
22127 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
22129 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
22130 if(!isWasmInitialized) {
22131 throw new Error("initializeWasm() must be awaited first!");
22133 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
22134 // debug statements here
22136 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22138 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
22139 if(!isWasmInitialized) {
22140 throw new Error("initializeWasm() must be awaited first!");
22142 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
22143 return nativeResponseValue;
22145 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22147 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
22148 if(!isWasmInitialized) {
22149 throw new Error("initializeWasm() must be awaited first!");
22151 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
22152 // debug statements here
22154 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22156 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
22157 if(!isWasmInitialized) {
22158 throw new Error("initializeWasm() must be awaited first!");
22160 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
22161 return nativeResponseValue;
22163 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22165 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
22166 if(!isWasmInitialized) {
22167 throw new Error("initializeWasm() must be awaited first!");
22169 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
22170 // debug statements here
22172 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22174 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
22175 if(!isWasmInitialized) {
22176 throw new Error("initializeWasm() must be awaited first!");
22178 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
22179 return nativeResponseValue;
22181 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22183 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
22184 if(!isWasmInitialized) {
22185 throw new Error("initializeWasm() must be awaited first!");
22187 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
22188 // debug statements here
22190 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22192 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
22193 if(!isWasmInitialized) {
22194 throw new Error("initializeWasm() must be awaited first!");
22196 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
22197 return nativeResponseValue;
22199 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22201 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
22202 if(!isWasmInitialized) {
22203 throw new Error("initializeWasm() must be awaited first!");
22205 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
22206 // debug statements here
22208 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
22210 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
22211 if(!isWasmInitialized) {
22212 throw new Error("initializeWasm() must be awaited first!");
22214 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
22215 return nativeResponseValue;
22217 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
22219 export function UnsignedChannelAnnouncement_clone(orig: number): number {
22220 if(!isWasmInitialized) {
22221 throw new Error("initializeWasm() must be awaited first!");
22223 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
22224 return nativeResponseValue;
22226 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
22228 export function ChannelAnnouncement_free(this_obj: number): void {
22229 if(!isWasmInitialized) {
22230 throw new Error("initializeWasm() must be awaited first!");
22232 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
22233 // debug statements here
22235 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22237 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
22238 if(!isWasmInitialized) {
22239 throw new Error("initializeWasm() must be awaited first!");
22241 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
22242 return nativeResponseValue;
22244 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22246 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
22247 if(!isWasmInitialized) {
22248 throw new Error("initializeWasm() must be awaited first!");
22250 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
22251 // debug statements here
22253 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22255 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
22256 if(!isWasmInitialized) {
22257 throw new Error("initializeWasm() must be awaited first!");
22259 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
22260 return nativeResponseValue;
22262 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22264 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
22265 if(!isWasmInitialized) {
22266 throw new Error("initializeWasm() must be awaited first!");
22268 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
22269 // debug statements here
22271 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22273 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
22274 if(!isWasmInitialized) {
22275 throw new Error("initializeWasm() must be awaited first!");
22277 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
22278 return nativeResponseValue;
22280 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22282 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
22283 if(!isWasmInitialized) {
22284 throw new Error("initializeWasm() must be awaited first!");
22286 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
22287 // debug statements here
22289 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22291 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
22292 if(!isWasmInitialized) {
22293 throw new Error("initializeWasm() must be awaited first!");
22295 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
22296 return nativeResponseValue;
22298 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22300 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
22301 if(!isWasmInitialized) {
22302 throw new Error("initializeWasm() must be awaited first!");
22304 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
22305 // debug statements here
22307 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22309 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
22310 if(!isWasmInitialized) {
22311 throw new Error("initializeWasm() must be awaited first!");
22313 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
22314 return nativeResponseValue;
22316 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
22318 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
22319 if(!isWasmInitialized) {
22320 throw new Error("initializeWasm() must be awaited first!");
22322 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
22323 // debug statements here
22325 // 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);
22327 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 {
22328 if(!isWasmInitialized) {
22329 throw new Error("initializeWasm() must be awaited first!");
22331 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
22332 return nativeResponseValue;
22334 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
22336 export function ChannelAnnouncement_clone_ptr(arg: number): number {
22337 if(!isWasmInitialized) {
22338 throw new Error("initializeWasm() must be awaited first!");
22340 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
22341 return nativeResponseValue;
22343 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
22345 export function ChannelAnnouncement_clone(orig: number): number {
22346 if(!isWasmInitialized) {
22347 throw new Error("initializeWasm() must be awaited first!");
22349 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
22350 return nativeResponseValue;
22352 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
22354 export function UnsignedChannelUpdate_free(this_obj: number): void {
22355 if(!isWasmInitialized) {
22356 throw new Error("initializeWasm() must be awaited first!");
22358 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
22359 // debug statements here
22361 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
22363 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
22364 if(!isWasmInitialized) {
22365 throw new Error("initializeWasm() must be awaited first!");
22367 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
22368 return nativeResponseValue;
22370 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22372 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
22373 if(!isWasmInitialized) {
22374 throw new Error("initializeWasm() must be awaited first!");
22376 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
22377 // debug statements here
22379 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22381 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
22382 if(!isWasmInitialized) {
22383 throw new Error("initializeWasm() must be awaited first!");
22385 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
22386 return nativeResponseValue;
22388 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
22390 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
22391 if(!isWasmInitialized) {
22392 throw new Error("initializeWasm() must be awaited first!");
22394 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
22395 // debug statements here
22397 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22399 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
22400 if(!isWasmInitialized) {
22401 throw new Error("initializeWasm() must be awaited first!");
22403 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
22404 return nativeResponseValue;
22406 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22408 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
22409 if(!isWasmInitialized) {
22410 throw new Error("initializeWasm() must be awaited first!");
22412 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
22413 // debug statements here
22415 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22417 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
22418 if(!isWasmInitialized) {
22419 throw new Error("initializeWasm() must be awaited first!");
22421 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
22422 return nativeResponseValue;
22424 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
22426 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
22427 if(!isWasmInitialized) {
22428 throw new Error("initializeWasm() must be awaited first!");
22430 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
22431 // debug statements here
22433 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22435 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
22436 if(!isWasmInitialized) {
22437 throw new Error("initializeWasm() must be awaited first!");
22439 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
22440 return nativeResponseValue;
22442 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
22444 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
22445 if(!isWasmInitialized) {
22446 throw new Error("initializeWasm() must be awaited first!");
22448 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
22449 // debug statements here
22451 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22453 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
22454 if(!isWasmInitialized) {
22455 throw new Error("initializeWasm() must be awaited first!");
22457 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
22458 return nativeResponseValue;
22460 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
22462 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
22463 if(!isWasmInitialized) {
22464 throw new Error("initializeWasm() must be awaited first!");
22466 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
22467 // debug statements here
22469 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22471 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
22472 if(!isWasmInitialized) {
22473 throw new Error("initializeWasm() must be awaited first!");
22475 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
22476 return nativeResponseValue;
22478 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22480 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
22481 if(!isWasmInitialized) {
22482 throw new Error("initializeWasm() must be awaited first!");
22484 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
22485 // debug statements here
22487 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
22489 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
22490 if(!isWasmInitialized) {
22491 throw new Error("initializeWasm() must be awaited first!");
22493 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
22494 return nativeResponseValue;
22496 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
22498 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
22499 if(!isWasmInitialized) {
22500 throw new Error("initializeWasm() must be awaited first!");
22502 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
22503 // debug statements here
22505 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
22507 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
22508 if(!isWasmInitialized) {
22509 throw new Error("initializeWasm() must be awaited first!");
22511 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
22512 return nativeResponseValue;
22514 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
22516 export function UnsignedChannelUpdate_clone(orig: number): number {
22517 if(!isWasmInitialized) {
22518 throw new Error("initializeWasm() must be awaited first!");
22520 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
22521 return nativeResponseValue;
22523 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
22525 export function ChannelUpdate_free(this_obj: number): void {
22526 if(!isWasmInitialized) {
22527 throw new Error("initializeWasm() must be awaited first!");
22529 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
22530 // debug statements here
22532 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
22534 export function ChannelUpdate_get_signature(this_ptr: number): number {
22535 if(!isWasmInitialized) {
22536 throw new Error("initializeWasm() must be awaited first!");
22538 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
22539 return nativeResponseValue;
22541 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
22543 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
22544 if(!isWasmInitialized) {
22545 throw new Error("initializeWasm() must be awaited first!");
22547 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
22548 // debug statements here
22550 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
22552 export function ChannelUpdate_get_contents(this_ptr: number): number {
22553 if(!isWasmInitialized) {
22554 throw new Error("initializeWasm() must be awaited first!");
22556 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
22557 return nativeResponseValue;
22559 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
22561 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
22562 if(!isWasmInitialized) {
22563 throw new Error("initializeWasm() must be awaited first!");
22565 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
22566 // debug statements here
22568 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
22570 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
22571 if(!isWasmInitialized) {
22572 throw new Error("initializeWasm() must be awaited first!");
22574 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
22575 return nativeResponseValue;
22577 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
22579 export function ChannelUpdate_clone_ptr(arg: number): number {
22580 if(!isWasmInitialized) {
22581 throw new Error("initializeWasm() must be awaited first!");
22583 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
22584 return nativeResponseValue;
22586 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
22588 export function ChannelUpdate_clone(orig: number): number {
22589 if(!isWasmInitialized) {
22590 throw new Error("initializeWasm() must be awaited first!");
22592 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
22593 return nativeResponseValue;
22595 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
22597 export function QueryChannelRange_free(this_obj: number): void {
22598 if(!isWasmInitialized) {
22599 throw new Error("initializeWasm() must be awaited first!");
22601 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
22602 // debug statements here
22604 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
22606 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
22607 if(!isWasmInitialized) {
22608 throw new Error("initializeWasm() must be awaited first!");
22610 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
22611 return nativeResponseValue;
22613 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22615 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
22616 if(!isWasmInitialized) {
22617 throw new Error("initializeWasm() must be awaited first!");
22619 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
22620 // debug statements here
22622 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
22624 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
22625 if(!isWasmInitialized) {
22626 throw new Error("initializeWasm() must be awaited first!");
22628 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
22629 return nativeResponseValue;
22631 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22633 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
22634 if(!isWasmInitialized) {
22635 throw new Error("initializeWasm() must be awaited first!");
22637 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
22638 // debug statements here
22640 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
22642 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
22643 if(!isWasmInitialized) {
22644 throw new Error("initializeWasm() must be awaited first!");
22646 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
22647 return nativeResponseValue;
22649 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22651 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
22652 if(!isWasmInitialized) {
22653 throw new Error("initializeWasm() must be awaited first!");
22655 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
22656 // debug statements here
22658 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
22660 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
22661 if(!isWasmInitialized) {
22662 throw new Error("initializeWasm() must be awaited first!");
22664 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
22665 return nativeResponseValue;
22667 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
22669 export function QueryChannelRange_clone_ptr(arg: number): number {
22670 if(!isWasmInitialized) {
22671 throw new Error("initializeWasm() must be awaited first!");
22673 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
22674 return nativeResponseValue;
22676 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
22678 export function QueryChannelRange_clone(orig: number): number {
22679 if(!isWasmInitialized) {
22680 throw new Error("initializeWasm() must be awaited first!");
22682 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
22683 return nativeResponseValue;
22685 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
22687 export function ReplyChannelRange_free(this_obj: number): void {
22688 if(!isWasmInitialized) {
22689 throw new Error("initializeWasm() must be awaited first!");
22691 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
22692 // debug statements here
22694 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
22696 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
22697 if(!isWasmInitialized) {
22698 throw new Error("initializeWasm() must be awaited first!");
22700 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
22701 return nativeResponseValue;
22703 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22705 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
22706 if(!isWasmInitialized) {
22707 throw new Error("initializeWasm() must be awaited first!");
22709 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
22710 // debug statements here
22712 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22714 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
22715 if(!isWasmInitialized) {
22716 throw new Error("initializeWasm() must be awaited first!");
22718 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
22719 return nativeResponseValue;
22721 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22723 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
22724 if(!isWasmInitialized) {
22725 throw new Error("initializeWasm() must be awaited first!");
22727 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
22728 // debug statements here
22730 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22732 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
22733 if(!isWasmInitialized) {
22734 throw new Error("initializeWasm() must be awaited first!");
22736 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
22737 return nativeResponseValue;
22739 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
22741 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
22742 if(!isWasmInitialized) {
22743 throw new Error("initializeWasm() must be awaited first!");
22745 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
22746 // debug statements here
22748 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
22750 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
22751 if(!isWasmInitialized) {
22752 throw new Error("initializeWasm() must be awaited first!");
22754 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
22755 return nativeResponseValue;
22757 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
22759 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
22760 if(!isWasmInitialized) {
22761 throw new Error("initializeWasm() must be awaited first!");
22763 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
22764 // debug statements here
22766 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
22768 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
22769 if(!isWasmInitialized) {
22770 throw new Error("initializeWasm() must be awaited first!");
22772 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
22773 // debug statements here
22775 // 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);
22777 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 {
22778 if(!isWasmInitialized) {
22779 throw new Error("initializeWasm() must be awaited first!");
22781 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
22782 return nativeResponseValue;
22784 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
22786 export function ReplyChannelRange_clone_ptr(arg: number): number {
22787 if(!isWasmInitialized) {
22788 throw new Error("initializeWasm() must be awaited first!");
22790 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
22791 return nativeResponseValue;
22793 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
22795 export function ReplyChannelRange_clone(orig: number): number {
22796 if(!isWasmInitialized) {
22797 throw new Error("initializeWasm() must be awaited first!");
22799 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
22800 return nativeResponseValue;
22802 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
22804 export function QueryShortChannelIds_free(this_obj: number): void {
22805 if(!isWasmInitialized) {
22806 throw new Error("initializeWasm() must be awaited first!");
22808 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
22809 // debug statements here
22811 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
22813 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
22814 if(!isWasmInitialized) {
22815 throw new Error("initializeWasm() must be awaited first!");
22817 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
22818 return nativeResponseValue;
22820 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22822 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
22823 if(!isWasmInitialized) {
22824 throw new Error("initializeWasm() must be awaited first!");
22826 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
22827 // debug statements here
22829 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
22831 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
22832 if(!isWasmInitialized) {
22833 throw new Error("initializeWasm() must be awaited first!");
22835 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
22836 // debug statements here
22838 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
22840 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
22841 if(!isWasmInitialized) {
22842 throw new Error("initializeWasm() must be awaited first!");
22844 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
22845 return nativeResponseValue;
22847 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
22849 export function QueryShortChannelIds_clone_ptr(arg: number): number {
22850 if(!isWasmInitialized) {
22851 throw new Error("initializeWasm() must be awaited first!");
22853 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
22854 return nativeResponseValue;
22856 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
22858 export function QueryShortChannelIds_clone(orig: number): number {
22859 if(!isWasmInitialized) {
22860 throw new Error("initializeWasm() must be awaited first!");
22862 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
22863 return nativeResponseValue;
22865 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
22867 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
22868 if(!isWasmInitialized) {
22869 throw new Error("initializeWasm() must be awaited first!");
22871 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
22872 // debug statements here
22874 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
22876 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
22877 if(!isWasmInitialized) {
22878 throw new Error("initializeWasm() must be awaited first!");
22880 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
22881 return nativeResponseValue;
22883 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22885 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
22886 if(!isWasmInitialized) {
22887 throw new Error("initializeWasm() must be awaited first!");
22889 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
22890 // debug statements here
22892 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
22894 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
22895 if(!isWasmInitialized) {
22896 throw new Error("initializeWasm() must be awaited first!");
22898 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
22899 return nativeResponseValue;
22901 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
22903 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
22904 if(!isWasmInitialized) {
22905 throw new Error("initializeWasm() must be awaited first!");
22907 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
22908 // debug statements here
22910 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
22912 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
22913 if(!isWasmInitialized) {
22914 throw new Error("initializeWasm() must be awaited first!");
22916 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
22917 return nativeResponseValue;
22919 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
22921 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
22922 if(!isWasmInitialized) {
22923 throw new Error("initializeWasm() must be awaited first!");
22925 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
22926 return nativeResponseValue;
22928 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
22930 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
22931 if(!isWasmInitialized) {
22932 throw new Error("initializeWasm() must be awaited first!");
22934 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
22935 return nativeResponseValue;
22937 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
22939 export function GossipTimestampFilter_free(this_obj: number): void {
22940 if(!isWasmInitialized) {
22941 throw new Error("initializeWasm() must be awaited first!");
22943 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
22944 // debug statements here
22946 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
22948 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
22949 if(!isWasmInitialized) {
22950 throw new Error("initializeWasm() must be awaited first!");
22952 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
22953 return nativeResponseValue;
22955 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22957 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
22958 if(!isWasmInitialized) {
22959 throw new Error("initializeWasm() must be awaited first!");
22961 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
22962 // debug statements here
22964 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
22966 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
22967 if(!isWasmInitialized) {
22968 throw new Error("initializeWasm() must be awaited first!");
22970 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
22971 return nativeResponseValue;
22973 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
22975 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
22976 if(!isWasmInitialized) {
22977 throw new Error("initializeWasm() must be awaited first!");
22979 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
22980 // debug statements here
22982 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
22984 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
22985 if(!isWasmInitialized) {
22986 throw new Error("initializeWasm() must be awaited first!");
22988 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
22989 return nativeResponseValue;
22991 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
22993 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
22994 if(!isWasmInitialized) {
22995 throw new Error("initializeWasm() must be awaited first!");
22997 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
22998 // debug statements here
23000 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
23002 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
23003 if(!isWasmInitialized) {
23004 throw new Error("initializeWasm() must be awaited first!");
23006 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
23007 return nativeResponseValue;
23009 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
23011 export function GossipTimestampFilter_clone_ptr(arg: number): number {
23012 if(!isWasmInitialized) {
23013 throw new Error("initializeWasm() must be awaited first!");
23015 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
23016 return nativeResponseValue;
23018 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
23020 export function GossipTimestampFilter_clone(orig: number): number {
23021 if(!isWasmInitialized) {
23022 throw new Error("initializeWasm() must be awaited first!");
23024 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
23025 return nativeResponseValue;
23027 // void ErrorAction_free(struct LDKErrorAction this_ptr);
23029 export function ErrorAction_free(this_ptr: number): void {
23030 if(!isWasmInitialized) {
23031 throw new Error("initializeWasm() must be awaited first!");
23033 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
23034 // debug statements here
23036 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
23038 export function ErrorAction_clone_ptr(arg: number): number {
23039 if(!isWasmInitialized) {
23040 throw new Error("initializeWasm() must be awaited first!");
23042 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
23043 return nativeResponseValue;
23045 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
23047 export function ErrorAction_clone(orig: number): number {
23048 if(!isWasmInitialized) {
23049 throw new Error("initializeWasm() must be awaited first!");
23051 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
23052 return nativeResponseValue;
23054 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
23056 export function ErrorAction_disconnect_peer(msg: number): number {
23057 if(!isWasmInitialized) {
23058 throw new Error("initializeWasm() must be awaited first!");
23060 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
23061 return nativeResponseValue;
23063 // struct LDKErrorAction ErrorAction_ignore_error(void);
23065 export function ErrorAction_ignore_error(): number {
23066 if(!isWasmInitialized) {
23067 throw new Error("initializeWasm() must be awaited first!");
23069 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
23070 return nativeResponseValue;
23072 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
23074 export function ErrorAction_ignore_and_log(a: Level): number {
23075 if(!isWasmInitialized) {
23076 throw new Error("initializeWasm() must be awaited first!");
23078 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
23079 return nativeResponseValue;
23081 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
23083 export function ErrorAction_ignore_duplicate_gossip(): number {
23084 if(!isWasmInitialized) {
23085 throw new Error("initializeWasm() must be awaited first!");
23087 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
23088 return nativeResponseValue;
23090 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
23092 export function ErrorAction_send_error_message(msg: number): number {
23093 if(!isWasmInitialized) {
23094 throw new Error("initializeWasm() must be awaited first!");
23096 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
23097 return nativeResponseValue;
23099 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
23101 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
23102 if(!isWasmInitialized) {
23103 throw new Error("initializeWasm() must be awaited first!");
23105 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
23106 return nativeResponseValue;
23108 // void LightningError_free(struct LDKLightningError this_obj);
23110 export function LightningError_free(this_obj: number): void {
23111 if(!isWasmInitialized) {
23112 throw new Error("initializeWasm() must be awaited first!");
23114 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
23115 // debug statements here
23117 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
23119 export function LightningError_get_err(this_ptr: number): number {
23120 if(!isWasmInitialized) {
23121 throw new Error("initializeWasm() must be awaited first!");
23123 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
23124 return nativeResponseValue;
23126 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
23128 export function LightningError_set_err(this_ptr: number, val: number): void {
23129 if(!isWasmInitialized) {
23130 throw new Error("initializeWasm() must be awaited first!");
23132 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
23133 // debug statements here
23135 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
23137 export function LightningError_get_action(this_ptr: number): number {
23138 if(!isWasmInitialized) {
23139 throw new Error("initializeWasm() must be awaited first!");
23141 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
23142 return nativeResponseValue;
23144 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
23146 export function LightningError_set_action(this_ptr: number, val: number): void {
23147 if(!isWasmInitialized) {
23148 throw new Error("initializeWasm() must be awaited first!");
23150 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
23151 // debug statements here
23153 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
23155 export function LightningError_new(err_arg: number, action_arg: number): number {
23156 if(!isWasmInitialized) {
23157 throw new Error("initializeWasm() must be awaited first!");
23159 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
23160 return nativeResponseValue;
23162 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
23164 export function LightningError_clone_ptr(arg: number): number {
23165 if(!isWasmInitialized) {
23166 throw new Error("initializeWasm() must be awaited first!");
23168 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
23169 return nativeResponseValue;
23171 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
23173 export function LightningError_clone(orig: number): number {
23174 if(!isWasmInitialized) {
23175 throw new Error("initializeWasm() must be awaited first!");
23177 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
23178 return nativeResponseValue;
23180 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
23182 export function CommitmentUpdate_free(this_obj: number): void {
23183 if(!isWasmInitialized) {
23184 throw new Error("initializeWasm() must be awaited first!");
23186 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
23187 // debug statements here
23189 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23191 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
23192 if(!isWasmInitialized) {
23193 throw new Error("initializeWasm() must be awaited first!");
23195 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
23196 return nativeResponseValue;
23198 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
23200 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
23201 if(!isWasmInitialized) {
23202 throw new Error("initializeWasm() must be awaited first!");
23204 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
23205 // debug statements here
23207 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23209 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
23210 if(!isWasmInitialized) {
23211 throw new Error("initializeWasm() must be awaited first!");
23213 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
23214 return nativeResponseValue;
23216 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
23218 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
23219 if(!isWasmInitialized) {
23220 throw new Error("initializeWasm() must be awaited first!");
23222 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
23223 // debug statements here
23225 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23227 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
23228 if(!isWasmInitialized) {
23229 throw new Error("initializeWasm() must be awaited first!");
23231 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
23232 return nativeResponseValue;
23234 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
23236 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
23237 if(!isWasmInitialized) {
23238 throw new Error("initializeWasm() must be awaited first!");
23240 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
23241 // debug statements here
23243 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23245 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
23246 if(!isWasmInitialized) {
23247 throw new Error("initializeWasm() must be awaited first!");
23249 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
23250 return nativeResponseValue;
23252 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
23254 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
23255 if(!isWasmInitialized) {
23256 throw new Error("initializeWasm() must be awaited first!");
23258 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
23259 // debug statements here
23261 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23263 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
23264 if(!isWasmInitialized) {
23265 throw new Error("initializeWasm() must be awaited first!");
23267 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
23268 return nativeResponseValue;
23270 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
23272 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
23273 if(!isWasmInitialized) {
23274 throw new Error("initializeWasm() must be awaited first!");
23276 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
23277 // debug statements here
23279 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23281 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
23282 if(!isWasmInitialized) {
23283 throw new Error("initializeWasm() must be awaited first!");
23285 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
23286 return nativeResponseValue;
23288 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
23290 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
23291 if(!isWasmInitialized) {
23292 throw new Error("initializeWasm() must be awaited first!");
23294 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
23295 // debug statements here
23297 // 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);
23299 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 {
23300 if(!isWasmInitialized) {
23301 throw new Error("initializeWasm() must be awaited first!");
23303 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);
23304 return nativeResponseValue;
23306 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
23308 export function CommitmentUpdate_clone_ptr(arg: number): number {
23309 if(!isWasmInitialized) {
23310 throw new Error("initializeWasm() must be awaited first!");
23312 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
23313 return nativeResponseValue;
23315 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
23317 export function CommitmentUpdate_clone(orig: number): number {
23318 if(!isWasmInitialized) {
23319 throw new Error("initializeWasm() must be awaited first!");
23321 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
23322 return nativeResponseValue;
23324 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
23326 export function ChannelMessageHandler_free(this_ptr: number): void {
23327 if(!isWasmInitialized) {
23328 throw new Error("initializeWasm() must be awaited first!");
23330 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
23331 // debug statements here
23333 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
23335 export function RoutingMessageHandler_free(this_ptr: number): void {
23336 if(!isWasmInitialized) {
23337 throw new Error("initializeWasm() must be awaited first!");
23339 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
23340 // debug statements here
23342 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
23344 export function AcceptChannel_write(obj: number): number {
23345 if(!isWasmInitialized) {
23346 throw new Error("initializeWasm() must be awaited first!");
23348 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
23349 return nativeResponseValue;
23351 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
23353 export function AcceptChannel_read(ser: number): number {
23354 if(!isWasmInitialized) {
23355 throw new Error("initializeWasm() must be awaited first!");
23357 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
23358 return nativeResponseValue;
23360 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
23362 export function AnnouncementSignatures_write(obj: number): number {
23363 if(!isWasmInitialized) {
23364 throw new Error("initializeWasm() must be awaited first!");
23366 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
23367 return nativeResponseValue;
23369 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
23371 export function AnnouncementSignatures_read(ser: number): number {
23372 if(!isWasmInitialized) {
23373 throw new Error("initializeWasm() must be awaited first!");
23375 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
23376 return nativeResponseValue;
23378 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
23380 export function ChannelReestablish_write(obj: number): number {
23381 if(!isWasmInitialized) {
23382 throw new Error("initializeWasm() must be awaited first!");
23384 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
23385 return nativeResponseValue;
23387 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
23389 export function ChannelReestablish_read(ser: number): number {
23390 if(!isWasmInitialized) {
23391 throw new Error("initializeWasm() must be awaited first!");
23393 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
23394 return nativeResponseValue;
23396 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
23398 export function ClosingSigned_write(obj: number): number {
23399 if(!isWasmInitialized) {
23400 throw new Error("initializeWasm() must be awaited first!");
23402 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
23403 return nativeResponseValue;
23405 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
23407 export function ClosingSigned_read(ser: number): number {
23408 if(!isWasmInitialized) {
23409 throw new Error("initializeWasm() must be awaited first!");
23411 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
23412 return nativeResponseValue;
23414 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
23416 export function ClosingSignedFeeRange_write(obj: number): number {
23417 if(!isWasmInitialized) {
23418 throw new Error("initializeWasm() must be awaited first!");
23420 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
23421 return nativeResponseValue;
23423 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
23425 export function ClosingSignedFeeRange_read(ser: number): number {
23426 if(!isWasmInitialized) {
23427 throw new Error("initializeWasm() must be awaited first!");
23429 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
23430 return nativeResponseValue;
23432 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
23434 export function CommitmentSigned_write(obj: number): number {
23435 if(!isWasmInitialized) {
23436 throw new Error("initializeWasm() must be awaited first!");
23438 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
23439 return nativeResponseValue;
23441 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
23443 export function CommitmentSigned_read(ser: number): number {
23444 if(!isWasmInitialized) {
23445 throw new Error("initializeWasm() must be awaited first!");
23447 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
23448 return nativeResponseValue;
23450 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
23452 export function FundingCreated_write(obj: number): number {
23453 if(!isWasmInitialized) {
23454 throw new Error("initializeWasm() must be awaited first!");
23456 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
23457 return nativeResponseValue;
23459 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
23461 export function FundingCreated_read(ser: number): number {
23462 if(!isWasmInitialized) {
23463 throw new Error("initializeWasm() must be awaited first!");
23465 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
23466 return nativeResponseValue;
23468 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
23470 export function FundingSigned_write(obj: number): number {
23471 if(!isWasmInitialized) {
23472 throw new Error("initializeWasm() must be awaited first!");
23474 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
23475 return nativeResponseValue;
23477 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
23479 export function FundingSigned_read(ser: number): number {
23480 if(!isWasmInitialized) {
23481 throw new Error("initializeWasm() must be awaited first!");
23483 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
23484 return nativeResponseValue;
23486 // struct LDKCVec_u8Z FundingLocked_write(const struct LDKFundingLocked *NONNULL_PTR obj);
23488 export function FundingLocked_write(obj: number): number {
23489 if(!isWasmInitialized) {
23490 throw new Error("initializeWasm() must be awaited first!");
23492 const nativeResponseValue = wasm.TS_FundingLocked_write(obj);
23493 return nativeResponseValue;
23495 // struct LDKCResult_FundingLockedDecodeErrorZ FundingLocked_read(struct LDKu8slice ser);
23497 export function FundingLocked_read(ser: number): number {
23498 if(!isWasmInitialized) {
23499 throw new Error("initializeWasm() must be awaited first!");
23501 const nativeResponseValue = wasm.TS_FundingLocked_read(ser);
23502 return nativeResponseValue;
23504 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
23506 export function Init_write(obj: number): number {
23507 if(!isWasmInitialized) {
23508 throw new Error("initializeWasm() must be awaited first!");
23510 const nativeResponseValue = wasm.TS_Init_write(obj);
23511 return nativeResponseValue;
23513 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
23515 export function Init_read(ser: number): number {
23516 if(!isWasmInitialized) {
23517 throw new Error("initializeWasm() must be awaited first!");
23519 const nativeResponseValue = wasm.TS_Init_read(ser);
23520 return nativeResponseValue;
23522 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
23524 export function OpenChannel_write(obj: number): number {
23525 if(!isWasmInitialized) {
23526 throw new Error("initializeWasm() must be awaited first!");
23528 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
23529 return nativeResponseValue;
23531 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
23533 export function OpenChannel_read(ser: number): number {
23534 if(!isWasmInitialized) {
23535 throw new Error("initializeWasm() must be awaited first!");
23537 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
23538 return nativeResponseValue;
23540 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
23542 export function RevokeAndACK_write(obj: number): number {
23543 if(!isWasmInitialized) {
23544 throw new Error("initializeWasm() must be awaited first!");
23546 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
23547 return nativeResponseValue;
23549 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
23551 export function RevokeAndACK_read(ser: number): number {
23552 if(!isWasmInitialized) {
23553 throw new Error("initializeWasm() must be awaited first!");
23555 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
23556 return nativeResponseValue;
23558 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
23560 export function Shutdown_write(obj: number): number {
23561 if(!isWasmInitialized) {
23562 throw new Error("initializeWasm() must be awaited first!");
23564 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
23565 return nativeResponseValue;
23567 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
23569 export function Shutdown_read(ser: number): number {
23570 if(!isWasmInitialized) {
23571 throw new Error("initializeWasm() must be awaited first!");
23573 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
23574 return nativeResponseValue;
23576 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
23578 export function UpdateFailHTLC_write(obj: number): number {
23579 if(!isWasmInitialized) {
23580 throw new Error("initializeWasm() must be awaited first!");
23582 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
23583 return nativeResponseValue;
23585 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
23587 export function UpdateFailHTLC_read(ser: number): number {
23588 if(!isWasmInitialized) {
23589 throw new Error("initializeWasm() must be awaited first!");
23591 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
23592 return nativeResponseValue;
23594 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
23596 export function UpdateFailMalformedHTLC_write(obj: number): number {
23597 if(!isWasmInitialized) {
23598 throw new Error("initializeWasm() must be awaited first!");
23600 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
23601 return nativeResponseValue;
23603 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
23605 export function UpdateFailMalformedHTLC_read(ser: number): number {
23606 if(!isWasmInitialized) {
23607 throw new Error("initializeWasm() must be awaited first!");
23609 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
23610 return nativeResponseValue;
23612 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
23614 export function UpdateFee_write(obj: number): number {
23615 if(!isWasmInitialized) {
23616 throw new Error("initializeWasm() must be awaited first!");
23618 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
23619 return nativeResponseValue;
23621 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
23623 export function UpdateFee_read(ser: number): number {
23624 if(!isWasmInitialized) {
23625 throw new Error("initializeWasm() must be awaited first!");
23627 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
23628 return nativeResponseValue;
23630 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
23632 export function UpdateFulfillHTLC_write(obj: number): number {
23633 if(!isWasmInitialized) {
23634 throw new Error("initializeWasm() must be awaited first!");
23636 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
23637 return nativeResponseValue;
23639 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
23641 export function UpdateFulfillHTLC_read(ser: number): number {
23642 if(!isWasmInitialized) {
23643 throw new Error("initializeWasm() must be awaited first!");
23645 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
23646 return nativeResponseValue;
23648 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
23650 export function UpdateAddHTLC_write(obj: number): number {
23651 if(!isWasmInitialized) {
23652 throw new Error("initializeWasm() must be awaited first!");
23654 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
23655 return nativeResponseValue;
23657 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
23659 export function UpdateAddHTLC_read(ser: number): number {
23660 if(!isWasmInitialized) {
23661 throw new Error("initializeWasm() must be awaited first!");
23663 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
23664 return nativeResponseValue;
23666 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
23668 export function Ping_write(obj: number): number {
23669 if(!isWasmInitialized) {
23670 throw new Error("initializeWasm() must be awaited first!");
23672 const nativeResponseValue = wasm.TS_Ping_write(obj);
23673 return nativeResponseValue;
23675 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
23677 export function Ping_read(ser: number): number {
23678 if(!isWasmInitialized) {
23679 throw new Error("initializeWasm() must be awaited first!");
23681 const nativeResponseValue = wasm.TS_Ping_read(ser);
23682 return nativeResponseValue;
23684 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
23686 export function Pong_write(obj: number): number {
23687 if(!isWasmInitialized) {
23688 throw new Error("initializeWasm() must be awaited first!");
23690 const nativeResponseValue = wasm.TS_Pong_write(obj);
23691 return nativeResponseValue;
23693 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
23695 export function Pong_read(ser: number): number {
23696 if(!isWasmInitialized) {
23697 throw new Error("initializeWasm() must be awaited first!");
23699 const nativeResponseValue = wasm.TS_Pong_read(ser);
23700 return nativeResponseValue;
23702 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
23704 export function UnsignedChannelAnnouncement_write(obj: number): number {
23705 if(!isWasmInitialized) {
23706 throw new Error("initializeWasm() must be awaited first!");
23708 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
23709 return nativeResponseValue;
23711 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
23713 export function UnsignedChannelAnnouncement_read(ser: number): number {
23714 if(!isWasmInitialized) {
23715 throw new Error("initializeWasm() must be awaited first!");
23717 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
23718 return nativeResponseValue;
23720 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
23722 export function ChannelAnnouncement_write(obj: number): number {
23723 if(!isWasmInitialized) {
23724 throw new Error("initializeWasm() must be awaited first!");
23726 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
23727 return nativeResponseValue;
23729 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
23731 export function ChannelAnnouncement_read(ser: number): number {
23732 if(!isWasmInitialized) {
23733 throw new Error("initializeWasm() must be awaited first!");
23735 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
23736 return nativeResponseValue;
23738 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
23740 export function UnsignedChannelUpdate_write(obj: number): number {
23741 if(!isWasmInitialized) {
23742 throw new Error("initializeWasm() must be awaited first!");
23744 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
23745 return nativeResponseValue;
23747 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
23749 export function UnsignedChannelUpdate_read(ser: number): number {
23750 if(!isWasmInitialized) {
23751 throw new Error("initializeWasm() must be awaited first!");
23753 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
23754 return nativeResponseValue;
23756 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
23758 export function ChannelUpdate_write(obj: number): number {
23759 if(!isWasmInitialized) {
23760 throw new Error("initializeWasm() must be awaited first!");
23762 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
23763 return nativeResponseValue;
23765 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
23767 export function ChannelUpdate_read(ser: number): number {
23768 if(!isWasmInitialized) {
23769 throw new Error("initializeWasm() must be awaited first!");
23771 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
23772 return nativeResponseValue;
23774 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
23776 export function ErrorMessage_write(obj: number): number {
23777 if(!isWasmInitialized) {
23778 throw new Error("initializeWasm() must be awaited first!");
23780 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
23781 return nativeResponseValue;
23783 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
23785 export function ErrorMessage_read(ser: number): number {
23786 if(!isWasmInitialized) {
23787 throw new Error("initializeWasm() must be awaited first!");
23789 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
23790 return nativeResponseValue;
23792 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
23794 export function WarningMessage_write(obj: number): number {
23795 if(!isWasmInitialized) {
23796 throw new Error("initializeWasm() must be awaited first!");
23798 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
23799 return nativeResponseValue;
23801 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
23803 export function WarningMessage_read(ser: number): number {
23804 if(!isWasmInitialized) {
23805 throw new Error("initializeWasm() must be awaited first!");
23807 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
23808 return nativeResponseValue;
23810 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
23812 export function UnsignedNodeAnnouncement_write(obj: number): number {
23813 if(!isWasmInitialized) {
23814 throw new Error("initializeWasm() must be awaited first!");
23816 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
23817 return nativeResponseValue;
23819 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
23821 export function UnsignedNodeAnnouncement_read(ser: number): number {
23822 if(!isWasmInitialized) {
23823 throw new Error("initializeWasm() must be awaited first!");
23825 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
23826 return nativeResponseValue;
23828 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
23830 export function NodeAnnouncement_write(obj: number): number {
23831 if(!isWasmInitialized) {
23832 throw new Error("initializeWasm() must be awaited first!");
23834 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
23835 return nativeResponseValue;
23837 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
23839 export function NodeAnnouncement_read(ser: number): number {
23840 if(!isWasmInitialized) {
23841 throw new Error("initializeWasm() must be awaited first!");
23843 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
23844 return nativeResponseValue;
23846 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
23848 export function QueryShortChannelIds_read(ser: number): number {
23849 if(!isWasmInitialized) {
23850 throw new Error("initializeWasm() must be awaited first!");
23852 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
23853 return nativeResponseValue;
23855 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
23857 export function QueryShortChannelIds_write(obj: number): number {
23858 if(!isWasmInitialized) {
23859 throw new Error("initializeWasm() must be awaited first!");
23861 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
23862 return nativeResponseValue;
23864 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
23866 export function ReplyShortChannelIdsEnd_write(obj: number): number {
23867 if(!isWasmInitialized) {
23868 throw new Error("initializeWasm() must be awaited first!");
23870 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
23871 return nativeResponseValue;
23873 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
23875 export function ReplyShortChannelIdsEnd_read(ser: number): number {
23876 if(!isWasmInitialized) {
23877 throw new Error("initializeWasm() must be awaited first!");
23879 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
23880 return nativeResponseValue;
23882 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
23884 export function QueryChannelRange_end_blocknum(this_arg: number): number {
23885 if(!isWasmInitialized) {
23886 throw new Error("initializeWasm() must be awaited first!");
23888 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
23889 return nativeResponseValue;
23891 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
23893 export function QueryChannelRange_write(obj: number): number {
23894 if(!isWasmInitialized) {
23895 throw new Error("initializeWasm() must be awaited first!");
23897 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
23898 return nativeResponseValue;
23900 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
23902 export function QueryChannelRange_read(ser: number): number {
23903 if(!isWasmInitialized) {
23904 throw new Error("initializeWasm() must be awaited first!");
23906 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
23907 return nativeResponseValue;
23909 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
23911 export function ReplyChannelRange_read(ser: number): number {
23912 if(!isWasmInitialized) {
23913 throw new Error("initializeWasm() must be awaited first!");
23915 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
23916 return nativeResponseValue;
23918 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
23920 export function ReplyChannelRange_write(obj: number): number {
23921 if(!isWasmInitialized) {
23922 throw new Error("initializeWasm() must be awaited first!");
23924 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
23925 return nativeResponseValue;
23927 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
23929 export function GossipTimestampFilter_write(obj: number): number {
23930 if(!isWasmInitialized) {
23931 throw new Error("initializeWasm() must be awaited first!");
23933 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
23934 return nativeResponseValue;
23936 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
23938 export function GossipTimestampFilter_read(ser: number): number {
23939 if(!isWasmInitialized) {
23940 throw new Error("initializeWasm() must be awaited first!");
23942 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
23943 return nativeResponseValue;
23945 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
23947 export function CustomMessageHandler_free(this_ptr: number): void {
23948 if(!isWasmInitialized) {
23949 throw new Error("initializeWasm() must be awaited first!");
23951 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
23952 // debug statements here
23954 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
23956 export function IgnoringMessageHandler_free(this_obj: number): void {
23957 if(!isWasmInitialized) {
23958 throw new Error("initializeWasm() must be awaited first!");
23960 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
23961 // debug statements here
23963 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
23965 export function IgnoringMessageHandler_new(): number {
23966 if(!isWasmInitialized) {
23967 throw new Error("initializeWasm() must be awaited first!");
23969 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
23970 return nativeResponseValue;
23972 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23974 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
23975 if(!isWasmInitialized) {
23976 throw new Error("initializeWasm() must be awaited first!");
23978 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
23979 return nativeResponseValue;
23981 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23983 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
23984 if(!isWasmInitialized) {
23985 throw new Error("initializeWasm() must be awaited first!");
23987 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
23988 return nativeResponseValue;
23990 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
23992 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
23993 if(!isWasmInitialized) {
23994 throw new Error("initializeWasm() must be awaited first!");
23996 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
23997 return nativeResponseValue;
23999 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24001 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
24002 if(!isWasmInitialized) {
24003 throw new Error("initializeWasm() must be awaited first!");
24005 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
24006 return nativeResponseValue;
24008 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
24010 export function ErroringMessageHandler_free(this_obj: number): void {
24011 if(!isWasmInitialized) {
24012 throw new Error("initializeWasm() must be awaited first!");
24014 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
24015 // debug statements here
24017 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
24019 export function ErroringMessageHandler_new(): number {
24020 if(!isWasmInitialized) {
24021 throw new Error("initializeWasm() must be awaited first!");
24023 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
24024 return nativeResponseValue;
24026 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24028 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24029 if(!isWasmInitialized) {
24030 throw new Error("initializeWasm() must be awaited first!");
24032 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
24033 return nativeResponseValue;
24035 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24037 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
24038 if(!isWasmInitialized) {
24039 throw new Error("initializeWasm() must be awaited first!");
24041 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
24042 return nativeResponseValue;
24044 // void MessageHandler_free(struct LDKMessageHandler this_obj);
24046 export function MessageHandler_free(this_obj: number): void {
24047 if(!isWasmInitialized) {
24048 throw new Error("initializeWasm() must be awaited first!");
24050 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
24051 // debug statements here
24053 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24055 export function MessageHandler_get_chan_handler(this_ptr: number): number {
24056 if(!isWasmInitialized) {
24057 throw new Error("initializeWasm() must be awaited first!");
24059 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
24060 return nativeResponseValue;
24062 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
24064 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
24065 if(!isWasmInitialized) {
24066 throw new Error("initializeWasm() must be awaited first!");
24068 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
24069 // debug statements here
24071 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24073 export function MessageHandler_get_route_handler(this_ptr: number): number {
24074 if(!isWasmInitialized) {
24075 throw new Error("initializeWasm() must be awaited first!");
24077 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
24078 return nativeResponseValue;
24080 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
24082 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
24083 if(!isWasmInitialized) {
24084 throw new Error("initializeWasm() must be awaited first!");
24086 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
24087 // debug statements here
24089 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
24091 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
24092 if(!isWasmInitialized) {
24093 throw new Error("initializeWasm() must be awaited first!");
24095 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
24096 return nativeResponseValue;
24098 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
24100 export function SocketDescriptor_clone_ptr(arg: number): number {
24101 if(!isWasmInitialized) {
24102 throw new Error("initializeWasm() must be awaited first!");
24104 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
24105 return nativeResponseValue;
24107 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
24109 export function SocketDescriptor_clone(orig: number): number {
24110 if(!isWasmInitialized) {
24111 throw new Error("initializeWasm() must be awaited first!");
24113 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
24114 return nativeResponseValue;
24116 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
24118 export function SocketDescriptor_free(this_ptr: number): void {
24119 if(!isWasmInitialized) {
24120 throw new Error("initializeWasm() must be awaited first!");
24122 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
24123 // debug statements here
24125 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
24127 export function PeerHandleError_free(this_obj: number): void {
24128 if(!isWasmInitialized) {
24129 throw new Error("initializeWasm() must be awaited first!");
24131 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
24132 // debug statements here
24134 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
24136 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
24137 if(!isWasmInitialized) {
24138 throw new Error("initializeWasm() must be awaited first!");
24140 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
24141 return nativeResponseValue;
24143 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
24145 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
24146 if(!isWasmInitialized) {
24147 throw new Error("initializeWasm() must be awaited first!");
24149 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
24150 // debug statements here
24152 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
24154 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
24155 if(!isWasmInitialized) {
24156 throw new Error("initializeWasm() must be awaited first!");
24158 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
24159 return nativeResponseValue;
24161 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
24163 export function PeerHandleError_clone_ptr(arg: number): number {
24164 if(!isWasmInitialized) {
24165 throw new Error("initializeWasm() must be awaited first!");
24167 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
24168 return nativeResponseValue;
24170 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
24172 export function PeerHandleError_clone(orig: number): number {
24173 if(!isWasmInitialized) {
24174 throw new Error("initializeWasm() must be awaited first!");
24176 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
24177 return nativeResponseValue;
24179 // void PeerManager_free(struct LDKPeerManager this_obj);
24181 export function PeerManager_free(this_obj: number): void {
24182 if(!isWasmInitialized) {
24183 throw new Error("initializeWasm() must be awaited first!");
24185 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
24186 // debug statements here
24188 // 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);
24190 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
24191 if(!isWasmInitialized) {
24192 throw new Error("initializeWasm() must be awaited first!");
24194 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
24195 return nativeResponseValue;
24197 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
24199 export function PeerManager_get_peer_node_ids(this_arg: number): number {
24200 if(!isWasmInitialized) {
24201 throw new Error("initializeWasm() must be awaited first!");
24203 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
24204 return nativeResponseValue;
24206 // 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);
24208 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
24209 if(!isWasmInitialized) {
24210 throw new Error("initializeWasm() must be awaited first!");
24212 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
24213 return nativeResponseValue;
24215 // 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);
24217 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
24218 if(!isWasmInitialized) {
24219 throw new Error("initializeWasm() must be awaited first!");
24221 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
24222 return nativeResponseValue;
24224 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24226 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
24227 if(!isWasmInitialized) {
24228 throw new Error("initializeWasm() must be awaited first!");
24230 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
24231 return nativeResponseValue;
24233 // 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);
24235 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
24236 if(!isWasmInitialized) {
24237 throw new Error("initializeWasm() must be awaited first!");
24239 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
24240 return nativeResponseValue;
24242 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
24244 export function PeerManager_process_events(this_arg: number): void {
24245 if(!isWasmInitialized) {
24246 throw new Error("initializeWasm() must be awaited first!");
24248 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
24249 // debug statements here
24251 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24253 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
24254 if(!isWasmInitialized) {
24255 throw new Error("initializeWasm() must be awaited first!");
24257 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
24258 // debug statements here
24260 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
24262 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
24263 if(!isWasmInitialized) {
24264 throw new Error("initializeWasm() must be awaited first!");
24266 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
24267 // debug statements here
24269 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
24271 export function PeerManager_disconnect_all_peers(this_arg: number): void {
24272 if(!isWasmInitialized) {
24273 throw new Error("initializeWasm() must be awaited first!");
24275 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
24276 // debug statements here
24278 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
24280 export function PeerManager_timer_tick_occurred(this_arg: number): void {
24281 if(!isWasmInitialized) {
24282 throw new Error("initializeWasm() must be awaited first!");
24284 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
24285 // debug statements here
24287 // uint64_t htlc_success_tx_weight(bool opt_anchors);
24289 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
24290 if(!isWasmInitialized) {
24291 throw new Error("initializeWasm() must be awaited first!");
24293 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
24294 return nativeResponseValue;
24296 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
24298 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
24299 if(!isWasmInitialized) {
24300 throw new Error("initializeWasm() must be awaited first!");
24302 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
24303 return nativeResponseValue;
24305 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
24307 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
24308 if(!isWasmInitialized) {
24309 throw new Error("initializeWasm() must be awaited first!");
24311 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
24312 return nativeResponseValue;
24314 // 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);
24316 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 {
24317 if(!isWasmInitialized) {
24318 throw new Error("initializeWasm() must be awaited first!");
24320 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
24321 return nativeResponseValue;
24323 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
24325 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
24326 if(!isWasmInitialized) {
24327 throw new Error("initializeWasm() must be awaited first!");
24329 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
24330 // debug statements here
24332 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
24334 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
24335 if(!isWasmInitialized) {
24336 throw new Error("initializeWasm() must be awaited first!");
24338 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
24339 return nativeResponseValue;
24341 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
24343 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
24344 if(!isWasmInitialized) {
24345 throw new Error("initializeWasm() must be awaited first!");
24347 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
24348 return nativeResponseValue;
24350 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
24352 export function CounterpartyCommitmentSecrets_new(): number {
24353 if(!isWasmInitialized) {
24354 throw new Error("initializeWasm() must be awaited first!");
24356 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
24357 return nativeResponseValue;
24359 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
24361 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
24362 if(!isWasmInitialized) {
24363 throw new Error("initializeWasm() must be awaited first!");
24365 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
24366 return nativeResponseValue;
24368 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
24370 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
24371 if(!isWasmInitialized) {
24372 throw new Error("initializeWasm() must be awaited first!");
24374 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
24375 return nativeResponseValue;
24377 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
24379 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
24380 if(!isWasmInitialized) {
24381 throw new Error("initializeWasm() must be awaited first!");
24383 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
24384 return nativeResponseValue;
24386 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
24388 export function CounterpartyCommitmentSecrets_write(obj: number): number {
24389 if(!isWasmInitialized) {
24390 throw new Error("initializeWasm() must be awaited first!");
24392 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
24393 return nativeResponseValue;
24395 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
24397 export function CounterpartyCommitmentSecrets_read(ser: number): number {
24398 if(!isWasmInitialized) {
24399 throw new Error("initializeWasm() must be awaited first!");
24401 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
24402 return nativeResponseValue;
24404 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
24406 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
24407 if(!isWasmInitialized) {
24408 throw new Error("initializeWasm() must be awaited first!");
24410 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
24411 return nativeResponseValue;
24413 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
24415 export function derive_public_key(per_commitment_point: number, base_point: number): number {
24416 if(!isWasmInitialized) {
24417 throw new Error("initializeWasm() must be awaited first!");
24419 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
24420 return nativeResponseValue;
24422 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
24424 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
24425 if(!isWasmInitialized) {
24426 throw new Error("initializeWasm() must be awaited first!");
24428 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
24429 return nativeResponseValue;
24431 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
24433 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
24434 if(!isWasmInitialized) {
24435 throw new Error("initializeWasm() must be awaited first!");
24437 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
24438 return nativeResponseValue;
24440 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
24442 export function TxCreationKeys_free(this_obj: number): void {
24443 if(!isWasmInitialized) {
24444 throw new Error("initializeWasm() must be awaited first!");
24446 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
24447 // debug statements here
24449 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24451 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
24452 if(!isWasmInitialized) {
24453 throw new Error("initializeWasm() must be awaited first!");
24455 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
24456 return nativeResponseValue;
24458 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24460 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
24461 if(!isWasmInitialized) {
24462 throw new Error("initializeWasm() must be awaited first!");
24464 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
24465 // debug statements here
24467 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24469 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
24470 if(!isWasmInitialized) {
24471 throw new Error("initializeWasm() must be awaited first!");
24473 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
24474 return nativeResponseValue;
24476 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24478 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
24479 if(!isWasmInitialized) {
24480 throw new Error("initializeWasm() must be awaited first!");
24482 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
24483 // debug statements here
24485 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24487 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
24488 if(!isWasmInitialized) {
24489 throw new Error("initializeWasm() must be awaited first!");
24491 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
24492 return nativeResponseValue;
24494 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24496 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
24497 if(!isWasmInitialized) {
24498 throw new Error("initializeWasm() must be awaited first!");
24500 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
24501 // debug statements here
24503 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24505 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
24506 if(!isWasmInitialized) {
24507 throw new Error("initializeWasm() must be awaited first!");
24509 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
24510 return nativeResponseValue;
24512 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24514 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
24515 if(!isWasmInitialized) {
24516 throw new Error("initializeWasm() must be awaited first!");
24518 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
24519 // debug statements here
24521 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
24523 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
24524 if(!isWasmInitialized) {
24525 throw new Error("initializeWasm() must be awaited first!");
24527 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
24528 return nativeResponseValue;
24530 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24532 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
24533 if(!isWasmInitialized) {
24534 throw new Error("initializeWasm() must be awaited first!");
24536 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
24537 // debug statements here
24539 // 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);
24541 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 {
24542 if(!isWasmInitialized) {
24543 throw new Error("initializeWasm() must be awaited first!");
24545 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);
24546 return nativeResponseValue;
24548 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
24550 export function TxCreationKeys_clone_ptr(arg: number): number {
24551 if(!isWasmInitialized) {
24552 throw new Error("initializeWasm() must be awaited first!");
24554 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
24555 return nativeResponseValue;
24557 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
24559 export function TxCreationKeys_clone(orig: number): number {
24560 if(!isWasmInitialized) {
24561 throw new Error("initializeWasm() must be awaited first!");
24563 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
24564 return nativeResponseValue;
24566 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
24568 export function TxCreationKeys_write(obj: number): number {
24569 if(!isWasmInitialized) {
24570 throw new Error("initializeWasm() must be awaited first!");
24572 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
24573 return nativeResponseValue;
24575 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
24577 export function TxCreationKeys_read(ser: number): number {
24578 if(!isWasmInitialized) {
24579 throw new Error("initializeWasm() must be awaited first!");
24581 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
24582 return nativeResponseValue;
24584 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
24586 export function ChannelPublicKeys_free(this_obj: number): void {
24587 if(!isWasmInitialized) {
24588 throw new Error("initializeWasm() must be awaited first!");
24590 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
24591 // debug statements here
24593 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24595 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
24596 if(!isWasmInitialized) {
24597 throw new Error("initializeWasm() must be awaited first!");
24599 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
24600 return nativeResponseValue;
24602 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24604 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
24605 if(!isWasmInitialized) {
24606 throw new Error("initializeWasm() must be awaited first!");
24608 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
24609 // debug statements here
24611 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24613 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
24614 if(!isWasmInitialized) {
24615 throw new Error("initializeWasm() must be awaited first!");
24617 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
24618 return nativeResponseValue;
24620 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24622 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
24623 if(!isWasmInitialized) {
24624 throw new Error("initializeWasm() must be awaited first!");
24626 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
24627 // debug statements here
24629 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24631 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
24632 if(!isWasmInitialized) {
24633 throw new Error("initializeWasm() must be awaited first!");
24635 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
24636 return nativeResponseValue;
24638 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24640 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
24641 if(!isWasmInitialized) {
24642 throw new Error("initializeWasm() must be awaited first!");
24644 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
24645 // debug statements here
24647 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24649 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
24650 if(!isWasmInitialized) {
24651 throw new Error("initializeWasm() must be awaited first!");
24653 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
24654 return nativeResponseValue;
24656 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24658 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
24659 if(!isWasmInitialized) {
24660 throw new Error("initializeWasm() must be awaited first!");
24662 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
24663 // debug statements here
24665 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
24667 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
24668 if(!isWasmInitialized) {
24669 throw new Error("initializeWasm() must be awaited first!");
24671 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
24672 return nativeResponseValue;
24674 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
24676 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
24677 if(!isWasmInitialized) {
24678 throw new Error("initializeWasm() must be awaited first!");
24680 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
24681 // debug statements here
24683 // 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);
24685 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 {
24686 if(!isWasmInitialized) {
24687 throw new Error("initializeWasm() must be awaited first!");
24689 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
24690 return nativeResponseValue;
24692 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
24694 export function ChannelPublicKeys_clone_ptr(arg: number): number {
24695 if(!isWasmInitialized) {
24696 throw new Error("initializeWasm() must be awaited first!");
24698 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
24699 return nativeResponseValue;
24701 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
24703 export function ChannelPublicKeys_clone(orig: number): number {
24704 if(!isWasmInitialized) {
24705 throw new Error("initializeWasm() must be awaited first!");
24707 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
24708 return nativeResponseValue;
24710 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
24712 export function ChannelPublicKeys_write(obj: number): number {
24713 if(!isWasmInitialized) {
24714 throw new Error("initializeWasm() must be awaited first!");
24716 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
24717 return nativeResponseValue;
24719 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
24721 export function ChannelPublicKeys_read(ser: number): number {
24722 if(!isWasmInitialized) {
24723 throw new Error("initializeWasm() must be awaited first!");
24725 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
24726 return nativeResponseValue;
24728 // 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);
24730 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 {
24731 if(!isWasmInitialized) {
24732 throw new Error("initializeWasm() must be awaited first!");
24734 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
24735 return nativeResponseValue;
24737 // 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);
24739 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
24740 if(!isWasmInitialized) {
24741 throw new Error("initializeWasm() must be awaited first!");
24743 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
24744 return nativeResponseValue;
24746 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
24748 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
24749 if(!isWasmInitialized) {
24750 throw new Error("initializeWasm() must be awaited first!");
24752 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
24753 return nativeResponseValue;
24755 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
24757 export function HTLCOutputInCommitment_free(this_obj: number): void {
24758 if(!isWasmInitialized) {
24759 throw new Error("initializeWasm() must be awaited first!");
24761 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
24762 // debug statements here
24764 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24766 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
24767 if(!isWasmInitialized) {
24768 throw new Error("initializeWasm() must be awaited first!");
24770 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
24771 return nativeResponseValue;
24773 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
24775 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
24776 if(!isWasmInitialized) {
24777 throw new Error("initializeWasm() must be awaited first!");
24779 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
24780 // debug statements here
24782 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24784 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
24785 if(!isWasmInitialized) {
24786 throw new Error("initializeWasm() must be awaited first!");
24788 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
24789 return nativeResponseValue;
24791 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
24793 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
24794 if(!isWasmInitialized) {
24795 throw new Error("initializeWasm() must be awaited first!");
24797 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
24798 // debug statements here
24800 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24802 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
24803 if(!isWasmInitialized) {
24804 throw new Error("initializeWasm() must be awaited first!");
24806 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
24807 return nativeResponseValue;
24809 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
24811 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
24812 if(!isWasmInitialized) {
24813 throw new Error("initializeWasm() must be awaited first!");
24815 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
24816 // debug statements here
24818 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
24820 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
24821 if(!isWasmInitialized) {
24822 throw new Error("initializeWasm() must be awaited first!");
24824 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
24825 return nativeResponseValue;
24827 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24829 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
24830 if(!isWasmInitialized) {
24831 throw new Error("initializeWasm() must be awaited first!");
24833 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
24834 // debug statements here
24836 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
24838 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
24839 if(!isWasmInitialized) {
24840 throw new Error("initializeWasm() must be awaited first!");
24842 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
24843 return nativeResponseValue;
24845 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
24847 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
24848 if(!isWasmInitialized) {
24849 throw new Error("initializeWasm() must be awaited first!");
24851 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
24852 // debug statements here
24854 // 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);
24856 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 {
24857 if(!isWasmInitialized) {
24858 throw new Error("initializeWasm() must be awaited first!");
24860 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
24861 return nativeResponseValue;
24863 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
24865 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
24866 if(!isWasmInitialized) {
24867 throw new Error("initializeWasm() must be awaited first!");
24869 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
24870 return nativeResponseValue;
24872 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
24874 export function HTLCOutputInCommitment_clone(orig: number): number {
24875 if(!isWasmInitialized) {
24876 throw new Error("initializeWasm() must be awaited first!");
24878 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
24879 return nativeResponseValue;
24881 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
24883 export function HTLCOutputInCommitment_write(obj: number): number {
24884 if(!isWasmInitialized) {
24885 throw new Error("initializeWasm() must be awaited first!");
24887 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
24888 return nativeResponseValue;
24890 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
24892 export function HTLCOutputInCommitment_read(ser: number): number {
24893 if(!isWasmInitialized) {
24894 throw new Error("initializeWasm() must be awaited first!");
24896 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
24897 return nativeResponseValue;
24899 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
24901 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
24902 if(!isWasmInitialized) {
24903 throw new Error("initializeWasm() must be awaited first!");
24905 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
24906 return nativeResponseValue;
24908 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
24910 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
24911 if(!isWasmInitialized) {
24912 throw new Error("initializeWasm() must be awaited first!");
24914 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
24915 return nativeResponseValue;
24917 // 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);
24919 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 {
24920 if(!isWasmInitialized) {
24921 throw new Error("initializeWasm() must be awaited first!");
24923 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
24924 return nativeResponseValue;
24926 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
24928 export function get_anchor_redeemscript(funding_pubkey: number): number {
24929 if(!isWasmInitialized) {
24930 throw new Error("initializeWasm() must be awaited first!");
24932 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
24933 return nativeResponseValue;
24935 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
24937 export function ChannelTransactionParameters_free(this_obj: number): void {
24938 if(!isWasmInitialized) {
24939 throw new Error("initializeWasm() must be awaited first!");
24941 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
24942 // debug statements here
24944 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24946 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
24947 if(!isWasmInitialized) {
24948 throw new Error("initializeWasm() must be awaited first!");
24950 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
24951 return nativeResponseValue;
24953 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
24955 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
24956 if(!isWasmInitialized) {
24957 throw new Error("initializeWasm() must be awaited first!");
24959 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
24960 // debug statements here
24962 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24964 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
24965 if(!isWasmInitialized) {
24966 throw new Error("initializeWasm() must be awaited first!");
24968 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
24969 return nativeResponseValue;
24971 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
24973 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
24974 if(!isWasmInitialized) {
24975 throw new Error("initializeWasm() must be awaited first!");
24977 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
24978 // debug statements here
24980 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
24982 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
24983 if(!isWasmInitialized) {
24984 throw new Error("initializeWasm() must be awaited first!");
24986 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
24987 return nativeResponseValue;
24989 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
24991 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
24992 if(!isWasmInitialized) {
24993 throw new Error("initializeWasm() must be awaited first!");
24995 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
24996 // debug statements here
24998 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25000 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
25001 if(!isWasmInitialized) {
25002 throw new Error("initializeWasm() must be awaited first!");
25004 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
25005 return nativeResponseValue;
25007 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
25009 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
25010 if(!isWasmInitialized) {
25011 throw new Error("initializeWasm() must be awaited first!");
25013 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
25014 // debug statements here
25016 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25018 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
25019 if(!isWasmInitialized) {
25020 throw new Error("initializeWasm() must be awaited first!");
25022 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
25023 return nativeResponseValue;
25025 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
25027 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
25028 if(!isWasmInitialized) {
25029 throw new Error("initializeWasm() must be awaited first!");
25031 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
25032 // debug statements here
25034 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25036 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
25037 if(!isWasmInitialized) {
25038 throw new Error("initializeWasm() must be awaited first!");
25040 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
25041 return nativeResponseValue;
25043 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
25045 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
25046 if(!isWasmInitialized) {
25047 throw new Error("initializeWasm() must be awaited first!");
25049 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
25050 // debug statements here
25052 // 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);
25054 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 {
25055 if(!isWasmInitialized) {
25056 throw new Error("initializeWasm() must be awaited first!");
25058 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);
25059 return nativeResponseValue;
25061 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
25063 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
25064 if(!isWasmInitialized) {
25065 throw new Error("initializeWasm() must be awaited first!");
25067 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
25068 return nativeResponseValue;
25070 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
25072 export function ChannelTransactionParameters_clone(orig: number): number {
25073 if(!isWasmInitialized) {
25074 throw new Error("initializeWasm() must be awaited first!");
25076 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
25077 return nativeResponseValue;
25079 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
25081 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
25082 if(!isWasmInitialized) {
25083 throw new Error("initializeWasm() must be awaited first!");
25085 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
25086 // debug statements here
25088 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25090 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
25091 if(!isWasmInitialized) {
25092 throw new Error("initializeWasm() must be awaited first!");
25094 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
25095 return nativeResponseValue;
25097 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25099 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
25100 if(!isWasmInitialized) {
25101 throw new Error("initializeWasm() must be awaited first!");
25103 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
25104 // debug statements here
25106 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25108 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
25109 if(!isWasmInitialized) {
25110 throw new Error("initializeWasm() must be awaited first!");
25112 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
25113 return nativeResponseValue;
25115 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25117 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
25118 if(!isWasmInitialized) {
25119 throw new Error("initializeWasm() must be awaited first!");
25121 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
25122 // debug statements here
25124 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
25126 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
25127 if(!isWasmInitialized) {
25128 throw new Error("initializeWasm() must be awaited first!");
25130 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
25131 return nativeResponseValue;
25133 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
25135 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
25136 if(!isWasmInitialized) {
25137 throw new Error("initializeWasm() must be awaited first!");
25139 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
25140 return nativeResponseValue;
25142 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
25144 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
25145 if(!isWasmInitialized) {
25146 throw new Error("initializeWasm() must be awaited first!");
25148 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
25149 return nativeResponseValue;
25151 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25153 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
25154 if(!isWasmInitialized) {
25155 throw new Error("initializeWasm() must be awaited first!");
25157 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
25158 return nativeResponseValue;
25160 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25162 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
25163 if(!isWasmInitialized) {
25164 throw new Error("initializeWasm() must be awaited first!");
25166 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
25167 return nativeResponseValue;
25169 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25171 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
25172 if(!isWasmInitialized) {
25173 throw new Error("initializeWasm() must be awaited first!");
25175 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
25176 return nativeResponseValue;
25178 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
25180 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
25181 if(!isWasmInitialized) {
25182 throw new Error("initializeWasm() must be awaited first!");
25184 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
25185 return nativeResponseValue;
25187 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
25189 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
25190 if(!isWasmInitialized) {
25191 throw new Error("initializeWasm() must be awaited first!");
25193 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
25194 return nativeResponseValue;
25196 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
25198 export function ChannelTransactionParameters_write(obj: number): number {
25199 if(!isWasmInitialized) {
25200 throw new Error("initializeWasm() must be awaited first!");
25202 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
25203 return nativeResponseValue;
25205 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
25207 export function ChannelTransactionParameters_read(ser: number): number {
25208 if(!isWasmInitialized) {
25209 throw new Error("initializeWasm() must be awaited first!");
25211 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
25212 return nativeResponseValue;
25214 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
25216 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
25217 if(!isWasmInitialized) {
25218 throw new Error("initializeWasm() must be awaited first!");
25220 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
25221 // debug statements here
25223 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25225 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
25226 if(!isWasmInitialized) {
25227 throw new Error("initializeWasm() must be awaited first!");
25229 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
25230 return nativeResponseValue;
25232 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25234 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
25235 if(!isWasmInitialized) {
25236 throw new Error("initializeWasm() must be awaited first!");
25238 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
25239 return nativeResponseValue;
25241 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25243 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
25244 if(!isWasmInitialized) {
25245 throw new Error("initializeWasm() must be awaited first!");
25247 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
25248 return nativeResponseValue;
25250 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25252 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
25253 if(!isWasmInitialized) {
25254 throw new Error("initializeWasm() must be awaited first!");
25256 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
25257 return nativeResponseValue;
25259 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25261 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
25262 if(!isWasmInitialized) {
25263 throw new Error("initializeWasm() must be awaited first!");
25265 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
25266 return nativeResponseValue;
25268 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25270 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
25271 if(!isWasmInitialized) {
25272 throw new Error("initializeWasm() must be awaited first!");
25274 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
25275 return nativeResponseValue;
25277 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
25279 export function HolderCommitmentTransaction_free(this_obj: number): void {
25280 if(!isWasmInitialized) {
25281 throw new Error("initializeWasm() must be awaited first!");
25283 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
25284 // debug statements here
25286 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
25288 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
25289 if(!isWasmInitialized) {
25290 throw new Error("initializeWasm() must be awaited first!");
25292 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
25293 return nativeResponseValue;
25295 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
25297 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
25298 if(!isWasmInitialized) {
25299 throw new Error("initializeWasm() must be awaited first!");
25301 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
25302 // debug statements here
25304 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
25306 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
25307 if(!isWasmInitialized) {
25308 throw new Error("initializeWasm() must be awaited first!");
25310 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
25311 // debug statements here
25313 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
25315 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
25316 if(!isWasmInitialized) {
25317 throw new Error("initializeWasm() must be awaited first!");
25319 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
25320 return nativeResponseValue;
25322 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
25324 export function HolderCommitmentTransaction_clone(orig: number): number {
25325 if(!isWasmInitialized) {
25326 throw new Error("initializeWasm() must be awaited first!");
25328 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
25329 return nativeResponseValue;
25331 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
25333 export function HolderCommitmentTransaction_write(obj: number): number {
25334 if(!isWasmInitialized) {
25335 throw new Error("initializeWasm() must be awaited first!");
25337 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
25338 return nativeResponseValue;
25340 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
25342 export function HolderCommitmentTransaction_read(ser: number): number {
25343 if(!isWasmInitialized) {
25344 throw new Error("initializeWasm() must be awaited first!");
25346 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
25347 return nativeResponseValue;
25349 // 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);
25351 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
25352 if(!isWasmInitialized) {
25353 throw new Error("initializeWasm() must be awaited first!");
25355 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
25356 return nativeResponseValue;
25358 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
25360 export function BuiltCommitmentTransaction_free(this_obj: number): void {
25361 if(!isWasmInitialized) {
25362 throw new Error("initializeWasm() must be awaited first!");
25364 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
25365 // debug statements here
25367 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
25369 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
25370 if(!isWasmInitialized) {
25371 throw new Error("initializeWasm() must be awaited first!");
25373 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
25374 return nativeResponseValue;
25376 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
25378 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
25379 if(!isWasmInitialized) {
25380 throw new Error("initializeWasm() must be awaited first!");
25382 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
25383 // debug statements here
25385 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
25387 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
25388 if(!isWasmInitialized) {
25389 throw new Error("initializeWasm() must be awaited first!");
25391 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
25392 return nativeResponseValue;
25394 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25396 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
25397 if(!isWasmInitialized) {
25398 throw new Error("initializeWasm() must be awaited first!");
25400 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
25401 // debug statements here
25403 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
25405 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
25406 if(!isWasmInitialized) {
25407 throw new Error("initializeWasm() must be awaited first!");
25409 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
25410 return nativeResponseValue;
25412 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
25414 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
25415 if(!isWasmInitialized) {
25416 throw new Error("initializeWasm() must be awaited first!");
25418 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
25419 return nativeResponseValue;
25421 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
25423 export function BuiltCommitmentTransaction_clone(orig: number): number {
25424 if(!isWasmInitialized) {
25425 throw new Error("initializeWasm() must be awaited first!");
25427 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
25428 return nativeResponseValue;
25430 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
25432 export function BuiltCommitmentTransaction_write(obj: number): number {
25433 if(!isWasmInitialized) {
25434 throw new Error("initializeWasm() must be awaited first!");
25436 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
25437 return nativeResponseValue;
25439 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
25441 export function BuiltCommitmentTransaction_read(ser: number): number {
25442 if(!isWasmInitialized) {
25443 throw new Error("initializeWasm() must be awaited first!");
25445 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
25446 return nativeResponseValue;
25448 // 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);
25450 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25451 if(!isWasmInitialized) {
25452 throw new Error("initializeWasm() must be awaited first!");
25454 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
25455 return nativeResponseValue;
25457 // 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);
25459 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25460 if(!isWasmInitialized) {
25461 throw new Error("initializeWasm() must be awaited first!");
25463 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
25464 return nativeResponseValue;
25466 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
25468 export function ClosingTransaction_free(this_obj: number): void {
25469 if(!isWasmInitialized) {
25470 throw new Error("initializeWasm() must be awaited first!");
25472 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
25473 // debug statements here
25475 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
25477 export function ClosingTransaction_clone_ptr(arg: number): number {
25478 if(!isWasmInitialized) {
25479 throw new Error("initializeWasm() must be awaited first!");
25481 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
25482 return nativeResponseValue;
25484 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
25486 export function ClosingTransaction_clone(orig: number): number {
25487 if(!isWasmInitialized) {
25488 throw new Error("initializeWasm() must be awaited first!");
25490 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
25491 return nativeResponseValue;
25493 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
25495 export function ClosingTransaction_hash(o: number): bigint {
25496 if(!isWasmInitialized) {
25497 throw new Error("initializeWasm() must be awaited first!");
25499 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
25500 return nativeResponseValue;
25502 // 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);
25504 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 {
25505 if(!isWasmInitialized) {
25506 throw new Error("initializeWasm() must be awaited first!");
25508 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25509 return nativeResponseValue;
25511 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25513 export function ClosingTransaction_trust(this_arg: number): number {
25514 if(!isWasmInitialized) {
25515 throw new Error("initializeWasm() must be awaited first!");
25517 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
25518 return nativeResponseValue;
25520 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
25522 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
25523 if(!isWasmInitialized) {
25524 throw new Error("initializeWasm() must be awaited first!");
25526 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
25527 return nativeResponseValue;
25529 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25531 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
25532 if(!isWasmInitialized) {
25533 throw new Error("initializeWasm() must be awaited first!");
25535 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
25536 return nativeResponseValue;
25538 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25540 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
25541 if(!isWasmInitialized) {
25542 throw new Error("initializeWasm() must be awaited first!");
25544 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
25545 return nativeResponseValue;
25547 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25549 export function ClosingTransaction_to_holder_script(this_arg: number): number {
25550 if(!isWasmInitialized) {
25551 throw new Error("initializeWasm() must be awaited first!");
25553 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
25554 return nativeResponseValue;
25556 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
25558 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
25559 if(!isWasmInitialized) {
25560 throw new Error("initializeWasm() must be awaited first!");
25562 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
25563 return nativeResponseValue;
25565 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
25567 export function TrustedClosingTransaction_free(this_obj: number): void {
25568 if(!isWasmInitialized) {
25569 throw new Error("initializeWasm() must be awaited first!");
25571 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
25572 // debug statements here
25574 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
25576 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
25577 if(!isWasmInitialized) {
25578 throw new Error("initializeWasm() must be awaited first!");
25580 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
25581 return nativeResponseValue;
25583 // 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);
25585 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25586 if(!isWasmInitialized) {
25587 throw new Error("initializeWasm() must be awaited first!");
25589 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
25590 return nativeResponseValue;
25592 // 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);
25594 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
25595 if(!isWasmInitialized) {
25596 throw new Error("initializeWasm() must be awaited first!");
25598 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
25599 return nativeResponseValue;
25601 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
25603 export function CommitmentTransaction_free(this_obj: number): void {
25604 if(!isWasmInitialized) {
25605 throw new Error("initializeWasm() must be awaited first!");
25607 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
25608 // debug statements here
25610 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
25612 export function CommitmentTransaction_clone_ptr(arg: number): number {
25613 if(!isWasmInitialized) {
25614 throw new Error("initializeWasm() must be awaited first!");
25616 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
25617 return nativeResponseValue;
25619 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
25621 export function CommitmentTransaction_clone(orig: number): number {
25622 if(!isWasmInitialized) {
25623 throw new Error("initializeWasm() must be awaited first!");
25625 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
25626 return nativeResponseValue;
25628 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
25630 export function CommitmentTransaction_write(obj: number): number {
25631 if(!isWasmInitialized) {
25632 throw new Error("initializeWasm() must be awaited first!");
25634 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
25635 return nativeResponseValue;
25637 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
25639 export function CommitmentTransaction_read(ser: number): number {
25640 if(!isWasmInitialized) {
25641 throw new Error("initializeWasm() must be awaited first!");
25643 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
25644 return nativeResponseValue;
25646 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25648 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
25649 if(!isWasmInitialized) {
25650 throw new Error("initializeWasm() must be awaited first!");
25652 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
25653 return nativeResponseValue;
25655 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25657 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
25658 if(!isWasmInitialized) {
25659 throw new Error("initializeWasm() must be awaited first!");
25661 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
25662 return nativeResponseValue;
25664 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25666 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
25667 if(!isWasmInitialized) {
25668 throw new Error("initializeWasm() must be awaited first!");
25670 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
25671 return nativeResponseValue;
25673 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25675 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
25676 if(!isWasmInitialized) {
25677 throw new Error("initializeWasm() must be awaited first!");
25679 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
25680 return nativeResponseValue;
25682 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
25684 export function CommitmentTransaction_trust(this_arg: number): number {
25685 if(!isWasmInitialized) {
25686 throw new Error("initializeWasm() must be awaited first!");
25688 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
25689 return nativeResponseValue;
25691 // 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);
25693 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
25694 if(!isWasmInitialized) {
25695 throw new Error("initializeWasm() must be awaited first!");
25697 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
25698 return nativeResponseValue;
25700 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
25702 export function TrustedCommitmentTransaction_free(this_obj: number): void {
25703 if(!isWasmInitialized) {
25704 throw new Error("initializeWasm() must be awaited first!");
25706 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
25707 // debug statements here
25709 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25711 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
25712 if(!isWasmInitialized) {
25713 throw new Error("initializeWasm() must be awaited first!");
25715 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
25716 return nativeResponseValue;
25718 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25720 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
25721 if(!isWasmInitialized) {
25722 throw new Error("initializeWasm() must be awaited first!");
25724 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
25725 return nativeResponseValue;
25727 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25729 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
25730 if(!isWasmInitialized) {
25731 throw new Error("initializeWasm() must be awaited first!");
25733 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
25734 return nativeResponseValue;
25736 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
25738 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
25739 if(!isWasmInitialized) {
25740 throw new Error("initializeWasm() must be awaited first!");
25742 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
25743 return nativeResponseValue;
25745 // 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);
25747 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
25748 if(!isWasmInitialized) {
25749 throw new Error("initializeWasm() must be awaited first!");
25751 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
25752 return nativeResponseValue;
25754 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
25756 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
25757 if(!isWasmInitialized) {
25758 throw new Error("initializeWasm() must be awaited first!");
25760 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
25761 return nativeResponseValue;
25763 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
25765 export function InitFeatures_eq(a: number, b: number): boolean {
25766 if(!isWasmInitialized) {
25767 throw new Error("initializeWasm() must be awaited first!");
25769 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
25770 return nativeResponseValue;
25772 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
25774 export function NodeFeatures_eq(a: number, b: number): boolean {
25775 if(!isWasmInitialized) {
25776 throw new Error("initializeWasm() must be awaited first!");
25778 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
25779 return nativeResponseValue;
25781 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
25783 export function ChannelFeatures_eq(a: number, b: number): boolean {
25784 if(!isWasmInitialized) {
25785 throw new Error("initializeWasm() must be awaited first!");
25787 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
25788 return nativeResponseValue;
25790 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
25792 export function InvoiceFeatures_eq(a: number, b: number): boolean {
25793 if(!isWasmInitialized) {
25794 throw new Error("initializeWasm() must be awaited first!");
25796 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
25797 return nativeResponseValue;
25799 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
25801 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
25802 if(!isWasmInitialized) {
25803 throw new Error("initializeWasm() must be awaited first!");
25805 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
25806 return nativeResponseValue;
25808 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
25810 export function InitFeatures_clone_ptr(arg: number): number {
25811 if(!isWasmInitialized) {
25812 throw new Error("initializeWasm() must be awaited first!");
25814 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
25815 return nativeResponseValue;
25817 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
25819 export function InitFeatures_clone(orig: number): number {
25820 if(!isWasmInitialized) {
25821 throw new Error("initializeWasm() must be awaited first!");
25823 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
25824 return nativeResponseValue;
25826 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
25828 export function NodeFeatures_clone_ptr(arg: number): number {
25829 if(!isWasmInitialized) {
25830 throw new Error("initializeWasm() must be awaited first!");
25832 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
25833 return nativeResponseValue;
25835 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
25837 export function NodeFeatures_clone(orig: number): number {
25838 if(!isWasmInitialized) {
25839 throw new Error("initializeWasm() must be awaited first!");
25841 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
25842 return nativeResponseValue;
25844 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
25846 export function ChannelFeatures_clone_ptr(arg: number): number {
25847 if(!isWasmInitialized) {
25848 throw new Error("initializeWasm() must be awaited first!");
25850 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
25851 return nativeResponseValue;
25853 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
25855 export function ChannelFeatures_clone(orig: number): number {
25856 if(!isWasmInitialized) {
25857 throw new Error("initializeWasm() must be awaited first!");
25859 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
25860 return nativeResponseValue;
25862 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
25864 export function InvoiceFeatures_clone_ptr(arg: number): number {
25865 if(!isWasmInitialized) {
25866 throw new Error("initializeWasm() must be awaited first!");
25868 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
25869 return nativeResponseValue;
25871 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
25873 export function InvoiceFeatures_clone(orig: number): number {
25874 if(!isWasmInitialized) {
25875 throw new Error("initializeWasm() must be awaited first!");
25877 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
25878 return nativeResponseValue;
25880 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
25882 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
25883 if(!isWasmInitialized) {
25884 throw new Error("initializeWasm() must be awaited first!");
25886 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
25887 return nativeResponseValue;
25889 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
25891 export function ChannelTypeFeatures_clone(orig: number): number {
25892 if(!isWasmInitialized) {
25893 throw new Error("initializeWasm() must be awaited first!");
25895 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
25896 return nativeResponseValue;
25898 // void InitFeatures_free(struct LDKInitFeatures this_obj);
25900 export function InitFeatures_free(this_obj: number): void {
25901 if(!isWasmInitialized) {
25902 throw new Error("initializeWasm() must be awaited first!");
25904 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
25905 // debug statements here
25907 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
25909 export function NodeFeatures_free(this_obj: number): void {
25910 if(!isWasmInitialized) {
25911 throw new Error("initializeWasm() must be awaited first!");
25913 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
25914 // debug statements here
25916 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
25918 export function ChannelFeatures_free(this_obj: number): void {
25919 if(!isWasmInitialized) {
25920 throw new Error("initializeWasm() must be awaited first!");
25922 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
25923 // debug statements here
25925 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
25927 export function InvoiceFeatures_free(this_obj: number): void {
25928 if(!isWasmInitialized) {
25929 throw new Error("initializeWasm() must be awaited first!");
25931 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
25932 // debug statements here
25934 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
25936 export function ChannelTypeFeatures_free(this_obj: number): void {
25937 if(!isWasmInitialized) {
25938 throw new Error("initializeWasm() must be awaited first!");
25940 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
25941 // debug statements here
25943 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
25945 export function InitFeatures_empty(): number {
25946 if(!isWasmInitialized) {
25947 throw new Error("initializeWasm() must be awaited first!");
25949 const nativeResponseValue = wasm.TS_InitFeatures_empty();
25950 return nativeResponseValue;
25952 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
25954 export function InitFeatures_known(): number {
25955 if(!isWasmInitialized) {
25956 throw new Error("initializeWasm() must be awaited first!");
25958 const nativeResponseValue = wasm.TS_InitFeatures_known();
25959 return nativeResponseValue;
25961 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
25963 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
25964 if(!isWasmInitialized) {
25965 throw new Error("initializeWasm() must be awaited first!");
25967 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
25968 return nativeResponseValue;
25970 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
25972 export function NodeFeatures_empty(): number {
25973 if(!isWasmInitialized) {
25974 throw new Error("initializeWasm() must be awaited first!");
25976 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
25977 return nativeResponseValue;
25979 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
25981 export function NodeFeatures_known(): number {
25982 if(!isWasmInitialized) {
25983 throw new Error("initializeWasm() must be awaited first!");
25985 const nativeResponseValue = wasm.TS_NodeFeatures_known();
25986 return nativeResponseValue;
25988 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
25990 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
25991 if(!isWasmInitialized) {
25992 throw new Error("initializeWasm() must be awaited first!");
25994 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
25995 return nativeResponseValue;
25997 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
25999 export function ChannelFeatures_empty(): number {
26000 if(!isWasmInitialized) {
26001 throw new Error("initializeWasm() must be awaited first!");
26003 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
26004 return nativeResponseValue;
26006 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
26008 export function ChannelFeatures_known(): number {
26009 if(!isWasmInitialized) {
26010 throw new Error("initializeWasm() must be awaited first!");
26012 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
26013 return nativeResponseValue;
26015 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
26017 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
26018 if(!isWasmInitialized) {
26019 throw new Error("initializeWasm() must be awaited first!");
26021 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
26022 return nativeResponseValue;
26024 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
26026 export function InvoiceFeatures_empty(): number {
26027 if(!isWasmInitialized) {
26028 throw new Error("initializeWasm() must be awaited first!");
26030 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
26031 return nativeResponseValue;
26033 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
26035 export function InvoiceFeatures_known(): number {
26036 if(!isWasmInitialized) {
26037 throw new Error("initializeWasm() must be awaited first!");
26039 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
26040 return nativeResponseValue;
26042 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
26044 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
26045 if(!isWasmInitialized) {
26046 throw new Error("initializeWasm() must be awaited first!");
26048 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
26049 return nativeResponseValue;
26051 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
26053 export function ChannelTypeFeatures_empty(): number {
26054 if(!isWasmInitialized) {
26055 throw new Error("initializeWasm() must be awaited first!");
26057 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
26058 return nativeResponseValue;
26060 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
26062 export function ChannelTypeFeatures_known(): number {
26063 if(!isWasmInitialized) {
26064 throw new Error("initializeWasm() must be awaited first!");
26066 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
26067 return nativeResponseValue;
26069 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
26071 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
26072 if(!isWasmInitialized) {
26073 throw new Error("initializeWasm() must be awaited first!");
26075 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
26076 return nativeResponseValue;
26078 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
26080 export function InitFeatures_write(obj: number): number {
26081 if(!isWasmInitialized) {
26082 throw new Error("initializeWasm() must be awaited first!");
26084 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
26085 return nativeResponseValue;
26087 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
26089 export function InitFeatures_read(ser: number): number {
26090 if(!isWasmInitialized) {
26091 throw new Error("initializeWasm() must be awaited first!");
26093 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
26094 return nativeResponseValue;
26096 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
26098 export function ChannelFeatures_write(obj: number): number {
26099 if(!isWasmInitialized) {
26100 throw new Error("initializeWasm() must be awaited first!");
26102 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
26103 return nativeResponseValue;
26105 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
26107 export function ChannelFeatures_read(ser: number): number {
26108 if(!isWasmInitialized) {
26109 throw new Error("initializeWasm() must be awaited first!");
26111 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
26112 return nativeResponseValue;
26114 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
26116 export function NodeFeatures_write(obj: number): number {
26117 if(!isWasmInitialized) {
26118 throw new Error("initializeWasm() must be awaited first!");
26120 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
26121 return nativeResponseValue;
26123 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
26125 export function NodeFeatures_read(ser: number): number {
26126 if(!isWasmInitialized) {
26127 throw new Error("initializeWasm() must be awaited first!");
26129 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
26130 return nativeResponseValue;
26132 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
26134 export function InvoiceFeatures_write(obj: number): number {
26135 if(!isWasmInitialized) {
26136 throw new Error("initializeWasm() must be awaited first!");
26138 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
26139 return nativeResponseValue;
26141 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
26143 export function InvoiceFeatures_read(ser: number): number {
26144 if(!isWasmInitialized) {
26145 throw new Error("initializeWasm() must be awaited first!");
26147 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
26148 return nativeResponseValue;
26150 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
26152 export function ChannelTypeFeatures_write(obj: number): number {
26153 if(!isWasmInitialized) {
26154 throw new Error("initializeWasm() must be awaited first!");
26156 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
26157 return nativeResponseValue;
26159 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
26161 export function ChannelTypeFeatures_read(ser: number): number {
26162 if(!isWasmInitialized) {
26163 throw new Error("initializeWasm() must be awaited first!");
26165 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
26166 return nativeResponseValue;
26168 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
26170 export function ShutdownScript_free(this_obj: number): void {
26171 if(!isWasmInitialized) {
26172 throw new Error("initializeWasm() must be awaited first!");
26174 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
26175 // debug statements here
26177 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
26179 export function ShutdownScript_clone_ptr(arg: number): number {
26180 if(!isWasmInitialized) {
26181 throw new Error("initializeWasm() must be awaited first!");
26183 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
26184 return nativeResponseValue;
26186 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
26188 export function ShutdownScript_clone(orig: number): number {
26189 if(!isWasmInitialized) {
26190 throw new Error("initializeWasm() must be awaited first!");
26192 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
26193 return nativeResponseValue;
26195 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
26197 export function InvalidShutdownScript_free(this_obj: number): void {
26198 if(!isWasmInitialized) {
26199 throw new Error("initializeWasm() must be awaited first!");
26201 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
26202 // debug statements here
26204 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
26206 export function InvalidShutdownScript_get_script(this_ptr: number): number {
26207 if(!isWasmInitialized) {
26208 throw new Error("initializeWasm() must be awaited first!");
26210 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
26211 return nativeResponseValue;
26213 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
26215 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
26216 if(!isWasmInitialized) {
26217 throw new Error("initializeWasm() must be awaited first!");
26219 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
26220 // debug statements here
26222 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
26224 export function InvalidShutdownScript_new(script_arg: number): number {
26225 if(!isWasmInitialized) {
26226 throw new Error("initializeWasm() must be awaited first!");
26228 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
26229 return nativeResponseValue;
26231 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
26233 export function InvalidShutdownScript_clone_ptr(arg: number): number {
26234 if(!isWasmInitialized) {
26235 throw new Error("initializeWasm() must be awaited first!");
26237 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
26238 return nativeResponseValue;
26240 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
26242 export function InvalidShutdownScript_clone(orig: number): number {
26243 if(!isWasmInitialized) {
26244 throw new Error("initializeWasm() must be awaited first!");
26246 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
26247 return nativeResponseValue;
26249 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
26251 export function ShutdownScript_write(obj: number): number {
26252 if(!isWasmInitialized) {
26253 throw new Error("initializeWasm() must be awaited first!");
26255 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
26256 return nativeResponseValue;
26258 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
26260 export function ShutdownScript_read(ser: number): number {
26261 if(!isWasmInitialized) {
26262 throw new Error("initializeWasm() must be awaited first!");
26264 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
26265 return nativeResponseValue;
26267 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
26269 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
26270 if(!isWasmInitialized) {
26271 throw new Error("initializeWasm() must be awaited first!");
26273 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
26274 return nativeResponseValue;
26276 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
26278 export function ShutdownScript_new_p2wsh(script_hash: number): number {
26279 if(!isWasmInitialized) {
26280 throw new Error("initializeWasm() must be awaited first!");
26282 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
26283 return nativeResponseValue;
26285 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(uint8_t version, struct LDKu8slice program);
26287 export function ShutdownScript_new_witness_program(version: number, program: number): number {
26288 if(!isWasmInitialized) {
26289 throw new Error("initializeWasm() must be awaited first!");
26291 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
26292 return nativeResponseValue;
26294 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
26296 export function ShutdownScript_into_inner(this_arg: number): number {
26297 if(!isWasmInitialized) {
26298 throw new Error("initializeWasm() must be awaited first!");
26300 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
26301 return nativeResponseValue;
26303 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
26305 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
26306 if(!isWasmInitialized) {
26307 throw new Error("initializeWasm() must be awaited first!");
26309 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
26310 return nativeResponseValue;
26312 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
26314 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
26315 if(!isWasmInitialized) {
26316 throw new Error("initializeWasm() must be awaited first!");
26318 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
26319 return nativeResponseValue;
26321 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
26323 export function CustomMessageReader_free(this_ptr: number): void {
26324 if(!isWasmInitialized) {
26325 throw new Error("initializeWasm() must be awaited first!");
26327 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
26328 // debug statements here
26330 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
26332 export function Type_clone_ptr(arg: number): number {
26333 if(!isWasmInitialized) {
26334 throw new Error("initializeWasm() must be awaited first!");
26336 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
26337 return nativeResponseValue;
26339 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
26341 export function Type_clone(orig: number): number {
26342 if(!isWasmInitialized) {
26343 throw new Error("initializeWasm() must be awaited first!");
26345 const nativeResponseValue = wasm.TS_Type_clone(orig);
26346 return nativeResponseValue;
26348 // void Type_free(struct LDKType this_ptr);
26350 export function Type_free(this_ptr: number): void {
26351 if(!isWasmInitialized) {
26352 throw new Error("initializeWasm() must be awaited first!");
26354 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
26355 // debug statements here
26357 // void NodeId_free(struct LDKNodeId this_obj);
26359 export function NodeId_free(this_obj: number): void {
26360 if(!isWasmInitialized) {
26361 throw new Error("initializeWasm() must be awaited first!");
26363 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
26364 // debug statements here
26366 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
26368 export function NodeId_clone_ptr(arg: number): number {
26369 if(!isWasmInitialized) {
26370 throw new Error("initializeWasm() must be awaited first!");
26372 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
26373 return nativeResponseValue;
26375 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
26377 export function NodeId_clone(orig: number): number {
26378 if(!isWasmInitialized) {
26379 throw new Error("initializeWasm() must be awaited first!");
26381 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
26382 return nativeResponseValue;
26384 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
26386 export function NodeId_from_pubkey(pubkey: number): number {
26387 if(!isWasmInitialized) {
26388 throw new Error("initializeWasm() must be awaited first!");
26390 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
26391 return nativeResponseValue;
26393 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
26395 export function NodeId_as_slice(this_arg: number): number {
26396 if(!isWasmInitialized) {
26397 throw new Error("initializeWasm() must be awaited first!");
26399 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
26400 return nativeResponseValue;
26402 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
26404 export function NodeId_hash(o: number): bigint {
26405 if(!isWasmInitialized) {
26406 throw new Error("initializeWasm() must be awaited first!");
26408 const nativeResponseValue = wasm.TS_NodeId_hash(o);
26409 return nativeResponseValue;
26411 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
26413 export function NodeId_write(obj: number): number {
26414 if(!isWasmInitialized) {
26415 throw new Error("initializeWasm() must be awaited first!");
26417 const nativeResponseValue = wasm.TS_NodeId_write(obj);
26418 return nativeResponseValue;
26420 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
26422 export function NodeId_read(ser: number): number {
26423 if(!isWasmInitialized) {
26424 throw new Error("initializeWasm() must be awaited first!");
26426 const nativeResponseValue = wasm.TS_NodeId_read(ser);
26427 return nativeResponseValue;
26429 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
26431 export function NetworkGraph_free(this_obj: number): void {
26432 if(!isWasmInitialized) {
26433 throw new Error("initializeWasm() must be awaited first!");
26435 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
26436 // debug statements here
26438 // uintptr_t NetworkGraph_clone_ptr(LDKNetworkGraph *NONNULL_PTR arg);
26440 export function NetworkGraph_clone_ptr(arg: number): number {
26441 if(!isWasmInitialized) {
26442 throw new Error("initializeWasm() must be awaited first!");
26444 const nativeResponseValue = wasm.TS_NetworkGraph_clone_ptr(arg);
26445 return nativeResponseValue;
26447 // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
26449 export function NetworkGraph_clone(orig: number): number {
26450 if(!isWasmInitialized) {
26451 throw new Error("initializeWasm() must be awaited first!");
26453 const nativeResponseValue = wasm.TS_NetworkGraph_clone(orig);
26454 return nativeResponseValue;
26456 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
26458 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
26459 if(!isWasmInitialized) {
26460 throw new Error("initializeWasm() must be awaited first!");
26462 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
26463 // debug statements here
26465 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
26467 export function NetworkUpdate_free(this_ptr: number): void {
26468 if(!isWasmInitialized) {
26469 throw new Error("initializeWasm() must be awaited first!");
26471 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
26472 // debug statements here
26474 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
26476 export function NetworkUpdate_clone_ptr(arg: number): number {
26477 if(!isWasmInitialized) {
26478 throw new Error("initializeWasm() must be awaited first!");
26480 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
26481 return nativeResponseValue;
26483 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
26485 export function NetworkUpdate_clone(orig: number): number {
26486 if(!isWasmInitialized) {
26487 throw new Error("initializeWasm() must be awaited first!");
26489 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
26490 return nativeResponseValue;
26492 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
26494 export function NetworkUpdate_channel_update_message(msg: number): number {
26495 if(!isWasmInitialized) {
26496 throw new Error("initializeWasm() must be awaited first!");
26498 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
26499 return nativeResponseValue;
26501 // struct LDKNetworkUpdate NetworkUpdate_channel_closed(uint64_t short_channel_id, bool is_permanent);
26503 export function NetworkUpdate_channel_closed(short_channel_id: bigint, is_permanent: boolean): number {
26504 if(!isWasmInitialized) {
26505 throw new Error("initializeWasm() must be awaited first!");
26507 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_closed(short_channel_id, is_permanent);
26508 return nativeResponseValue;
26510 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
26512 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
26513 if(!isWasmInitialized) {
26514 throw new Error("initializeWasm() must be awaited first!");
26516 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
26517 return nativeResponseValue;
26519 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
26521 export function NetworkUpdate_write(obj: number): number {
26522 if(!isWasmInitialized) {
26523 throw new Error("initializeWasm() must be awaited first!");
26525 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
26526 return nativeResponseValue;
26528 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
26530 export function NetworkUpdate_read(ser: number): number {
26531 if(!isWasmInitialized) {
26532 throw new Error("initializeWasm() must be awaited first!");
26534 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
26535 return nativeResponseValue;
26537 // struct LDKEventHandler NetGraphMsgHandler_as_EventHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26539 export function NetGraphMsgHandler_as_EventHandler(this_arg: number): number {
26540 if(!isWasmInitialized) {
26541 throw new Error("initializeWasm() must be awaited first!");
26543 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_EventHandler(this_arg);
26544 return nativeResponseValue;
26546 // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
26548 export function NetGraphMsgHandler_free(this_obj: number): void {
26549 if(!isWasmInitialized) {
26550 throw new Error("initializeWasm() must be awaited first!");
26552 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_free(this_obj);
26553 // debug statements here
26555 // MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
26557 export function NetGraphMsgHandler_new(network_graph: number, chain_access: number, logger: number): number {
26558 if(!isWasmInitialized) {
26559 throw new Error("initializeWasm() must be awaited first!");
26561 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_new(network_graph, chain_access, logger);
26562 return nativeResponseValue;
26564 // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
26566 export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void {
26567 if(!isWasmInitialized) {
26568 throw new Error("initializeWasm() must be awaited first!");
26570 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_add_chain_access(this_arg, chain_access);
26571 // debug statements here
26573 // struct LDKRoutingMessageHandler NetGraphMsgHandler_as_RoutingMessageHandler(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26575 export function NetGraphMsgHandler_as_RoutingMessageHandler(this_arg: number): number {
26576 if(!isWasmInitialized) {
26577 throw new Error("initializeWasm() must be awaited first!");
26579 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_RoutingMessageHandler(this_arg);
26580 return nativeResponseValue;
26582 // struct LDKMessageSendEventsProvider NetGraphMsgHandler_as_MessageSendEventsProvider(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg);
26584 export function NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg: number): number {
26585 if(!isWasmInitialized) {
26586 throw new Error("initializeWasm() must be awaited first!");
26588 const nativeResponseValue = wasm.TS_NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg);
26589 return nativeResponseValue;
26591 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
26593 export function ChannelUpdateInfo_free(this_obj: number): void {
26594 if(!isWasmInitialized) {
26595 throw new Error("initializeWasm() must be awaited first!");
26597 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
26598 // debug statements here
26600 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26602 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
26603 if(!isWasmInitialized) {
26604 throw new Error("initializeWasm() must be awaited first!");
26606 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
26607 return nativeResponseValue;
26609 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
26611 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
26612 if(!isWasmInitialized) {
26613 throw new Error("initializeWasm() must be awaited first!");
26615 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
26616 // debug statements here
26618 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26620 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
26621 if(!isWasmInitialized) {
26622 throw new Error("initializeWasm() must be awaited first!");
26624 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
26625 return nativeResponseValue;
26627 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
26629 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
26630 if(!isWasmInitialized) {
26631 throw new Error("initializeWasm() must be awaited first!");
26633 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
26634 // debug statements here
26636 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26638 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
26639 if(!isWasmInitialized) {
26640 throw new Error("initializeWasm() must be awaited first!");
26642 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
26643 return nativeResponseValue;
26645 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
26647 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
26648 if(!isWasmInitialized) {
26649 throw new Error("initializeWasm() must be awaited first!");
26651 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
26652 // debug statements here
26654 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26656 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
26657 if(!isWasmInitialized) {
26658 throw new Error("initializeWasm() must be awaited first!");
26660 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
26661 return nativeResponseValue;
26663 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
26665 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
26666 if(!isWasmInitialized) {
26667 throw new Error("initializeWasm() must be awaited first!");
26669 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
26670 // debug statements here
26672 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26674 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
26675 if(!isWasmInitialized) {
26676 throw new Error("initializeWasm() must be awaited first!");
26678 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
26679 return nativeResponseValue;
26681 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26683 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
26684 if(!isWasmInitialized) {
26685 throw new Error("initializeWasm() must be awaited first!");
26687 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
26688 // debug statements here
26690 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26692 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
26693 if(!isWasmInitialized) {
26694 throw new Error("initializeWasm() must be awaited first!");
26696 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
26697 return nativeResponseValue;
26699 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
26701 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
26702 if(!isWasmInitialized) {
26703 throw new Error("initializeWasm() must be awaited first!");
26705 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
26706 // debug statements here
26708 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
26710 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
26711 if(!isWasmInitialized) {
26712 throw new Error("initializeWasm() must be awaited first!");
26714 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
26715 return nativeResponseValue;
26717 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
26719 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
26720 if(!isWasmInitialized) {
26721 throw new Error("initializeWasm() must be awaited first!");
26723 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
26724 // debug statements here
26726 // 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);
26728 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 {
26729 if(!isWasmInitialized) {
26730 throw new Error("initializeWasm() must be awaited first!");
26732 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);
26733 return nativeResponseValue;
26735 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
26737 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
26738 if(!isWasmInitialized) {
26739 throw new Error("initializeWasm() must be awaited first!");
26741 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
26742 return nativeResponseValue;
26744 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
26746 export function ChannelUpdateInfo_clone(orig: number): number {
26747 if(!isWasmInitialized) {
26748 throw new Error("initializeWasm() must be awaited first!");
26750 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
26751 return nativeResponseValue;
26753 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
26755 export function ChannelUpdateInfo_write(obj: number): number {
26756 if(!isWasmInitialized) {
26757 throw new Error("initializeWasm() must be awaited first!");
26759 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
26760 return nativeResponseValue;
26762 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
26764 export function ChannelUpdateInfo_read(ser: number): number {
26765 if(!isWasmInitialized) {
26766 throw new Error("initializeWasm() must be awaited first!");
26768 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
26769 return nativeResponseValue;
26771 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
26773 export function ChannelInfo_free(this_obj: number): void {
26774 if(!isWasmInitialized) {
26775 throw new Error("initializeWasm() must be awaited first!");
26777 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
26778 // debug statements here
26780 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26782 export function ChannelInfo_get_features(this_ptr: number): number {
26783 if(!isWasmInitialized) {
26784 throw new Error("initializeWasm() must be awaited first!");
26786 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
26787 return nativeResponseValue;
26789 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
26791 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
26792 if(!isWasmInitialized) {
26793 throw new Error("initializeWasm() must be awaited first!");
26795 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
26796 // debug statements here
26798 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26800 export function ChannelInfo_get_node_one(this_ptr: number): number {
26801 if(!isWasmInitialized) {
26802 throw new Error("initializeWasm() must be awaited first!");
26804 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
26805 return nativeResponseValue;
26807 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
26809 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
26810 if(!isWasmInitialized) {
26811 throw new Error("initializeWasm() must be awaited first!");
26813 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
26814 // debug statements here
26816 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26818 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
26819 if(!isWasmInitialized) {
26820 throw new Error("initializeWasm() must be awaited first!");
26822 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
26823 return nativeResponseValue;
26825 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
26827 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
26828 if(!isWasmInitialized) {
26829 throw new Error("initializeWasm() must be awaited first!");
26831 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
26832 // debug statements here
26834 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26836 export function ChannelInfo_get_node_two(this_ptr: number): number {
26837 if(!isWasmInitialized) {
26838 throw new Error("initializeWasm() must be awaited first!");
26840 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
26841 return nativeResponseValue;
26843 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
26845 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
26846 if(!isWasmInitialized) {
26847 throw new Error("initializeWasm() must be awaited first!");
26849 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
26850 // debug statements here
26852 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26854 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
26855 if(!isWasmInitialized) {
26856 throw new Error("initializeWasm() must be awaited first!");
26858 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
26859 return nativeResponseValue;
26861 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
26863 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
26864 if(!isWasmInitialized) {
26865 throw new Error("initializeWasm() must be awaited first!");
26867 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
26868 // debug statements here
26870 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26872 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
26873 if(!isWasmInitialized) {
26874 throw new Error("initializeWasm() must be awaited first!");
26876 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
26877 return nativeResponseValue;
26879 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
26881 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
26882 if(!isWasmInitialized) {
26883 throw new Error("initializeWasm() must be awaited first!");
26885 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
26886 // debug statements here
26888 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
26890 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
26891 if(!isWasmInitialized) {
26892 throw new Error("initializeWasm() must be awaited first!");
26894 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
26895 return nativeResponseValue;
26897 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
26899 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
26900 if(!isWasmInitialized) {
26901 throw new Error("initializeWasm() must be awaited first!");
26903 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
26904 // debug statements here
26906 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
26908 export function ChannelInfo_clone_ptr(arg: number): number {
26909 if(!isWasmInitialized) {
26910 throw new Error("initializeWasm() must be awaited first!");
26912 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
26913 return nativeResponseValue;
26915 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
26917 export function ChannelInfo_clone(orig: number): number {
26918 if(!isWasmInitialized) {
26919 throw new Error("initializeWasm() must be awaited first!");
26921 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
26922 return nativeResponseValue;
26924 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
26926 export function ChannelInfo_write(obj: number): number {
26927 if(!isWasmInitialized) {
26928 throw new Error("initializeWasm() must be awaited first!");
26930 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
26931 return nativeResponseValue;
26933 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
26935 export function ChannelInfo_read(ser: number): number {
26936 if(!isWasmInitialized) {
26937 throw new Error("initializeWasm() must be awaited first!");
26939 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
26940 return nativeResponseValue;
26942 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
26944 export function DirectedChannelInfo_free(this_obj: number): void {
26945 if(!isWasmInitialized) {
26946 throw new Error("initializeWasm() must be awaited first!");
26948 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
26949 // debug statements here
26951 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
26953 export function DirectedChannelInfo_clone_ptr(arg: number): number {
26954 if(!isWasmInitialized) {
26955 throw new Error("initializeWasm() must be awaited first!");
26957 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
26958 return nativeResponseValue;
26960 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
26962 export function DirectedChannelInfo_clone(orig: number): number {
26963 if(!isWasmInitialized) {
26964 throw new Error("initializeWasm() must be awaited first!");
26966 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
26967 return nativeResponseValue;
26969 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26971 export function DirectedChannelInfo_channel(this_arg: number): number {
26972 if(!isWasmInitialized) {
26973 throw new Error("initializeWasm() must be awaited first!");
26975 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
26976 return nativeResponseValue;
26978 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26980 export function DirectedChannelInfo_direction(this_arg: number): number {
26981 if(!isWasmInitialized) {
26982 throw new Error("initializeWasm() must be awaited first!");
26984 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
26985 return nativeResponseValue;
26987 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
26989 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
26990 if(!isWasmInitialized) {
26991 throw new Error("initializeWasm() must be awaited first!");
26993 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
26994 return nativeResponseValue;
26996 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
26998 export function EffectiveCapacity_free(this_ptr: number): void {
26999 if(!isWasmInitialized) {
27000 throw new Error("initializeWasm() must be awaited first!");
27002 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
27003 // debug statements here
27005 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
27007 export function EffectiveCapacity_clone_ptr(arg: number): number {
27008 if(!isWasmInitialized) {
27009 throw new Error("initializeWasm() must be awaited first!");
27011 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
27012 return nativeResponseValue;
27014 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
27016 export function EffectiveCapacity_clone(orig: number): number {
27017 if(!isWasmInitialized) {
27018 throw new Error("initializeWasm() must be awaited first!");
27020 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
27021 return nativeResponseValue;
27023 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
27025 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
27026 if(!isWasmInitialized) {
27027 throw new Error("initializeWasm() must be awaited first!");
27029 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
27030 return nativeResponseValue;
27032 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
27034 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
27035 if(!isWasmInitialized) {
27036 throw new Error("initializeWasm() must be awaited first!");
27038 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
27039 return nativeResponseValue;
27041 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat);
27043 export function EffectiveCapacity_total(capacity_msat: bigint): number {
27044 if(!isWasmInitialized) {
27045 throw new Error("initializeWasm() must be awaited first!");
27047 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat);
27048 return nativeResponseValue;
27050 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
27052 export function EffectiveCapacity_infinite(): number {
27053 if(!isWasmInitialized) {
27054 throw new Error("initializeWasm() must be awaited first!");
27056 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
27057 return nativeResponseValue;
27059 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
27061 export function EffectiveCapacity_unknown(): number {
27062 if(!isWasmInitialized) {
27063 throw new Error("initializeWasm() must be awaited first!");
27065 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
27066 return nativeResponseValue;
27068 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
27070 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
27071 if(!isWasmInitialized) {
27072 throw new Error("initializeWasm() must be awaited first!");
27074 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
27075 return nativeResponseValue;
27077 // void RoutingFees_free(struct LDKRoutingFees this_obj);
27079 export function RoutingFees_free(this_obj: number): void {
27080 if(!isWasmInitialized) {
27081 throw new Error("initializeWasm() must be awaited first!");
27083 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
27084 // debug statements here
27086 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
27088 export function RoutingFees_get_base_msat(this_ptr: number): number {
27089 if(!isWasmInitialized) {
27090 throw new Error("initializeWasm() must be awaited first!");
27092 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
27093 return nativeResponseValue;
27095 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
27097 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
27098 if(!isWasmInitialized) {
27099 throw new Error("initializeWasm() must be awaited first!");
27101 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
27102 // debug statements here
27104 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
27106 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
27107 if(!isWasmInitialized) {
27108 throw new Error("initializeWasm() must be awaited first!");
27110 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
27111 return nativeResponseValue;
27113 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
27115 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
27116 if(!isWasmInitialized) {
27117 throw new Error("initializeWasm() must be awaited first!");
27119 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
27120 // debug statements here
27122 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
27124 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
27125 if(!isWasmInitialized) {
27126 throw new Error("initializeWasm() must be awaited first!");
27128 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
27129 return nativeResponseValue;
27131 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
27133 export function RoutingFees_eq(a: number, b: number): boolean {
27134 if(!isWasmInitialized) {
27135 throw new Error("initializeWasm() must be awaited first!");
27137 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
27138 return nativeResponseValue;
27140 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
27142 export function RoutingFees_clone_ptr(arg: number): number {
27143 if(!isWasmInitialized) {
27144 throw new Error("initializeWasm() must be awaited first!");
27146 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
27147 return nativeResponseValue;
27149 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
27151 export function RoutingFees_clone(orig: number): number {
27152 if(!isWasmInitialized) {
27153 throw new Error("initializeWasm() must be awaited first!");
27155 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
27156 return nativeResponseValue;
27158 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
27160 export function RoutingFees_hash(o: number): bigint {
27161 if(!isWasmInitialized) {
27162 throw new Error("initializeWasm() must be awaited first!");
27164 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
27165 return nativeResponseValue;
27167 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
27169 export function RoutingFees_write(obj: number): number {
27170 if(!isWasmInitialized) {
27171 throw new Error("initializeWasm() must be awaited first!");
27173 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
27174 return nativeResponseValue;
27176 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
27178 export function RoutingFees_read(ser: number): number {
27179 if(!isWasmInitialized) {
27180 throw new Error("initializeWasm() must be awaited first!");
27182 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
27183 return nativeResponseValue;
27185 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
27187 export function NodeAnnouncementInfo_free(this_obj: number): void {
27188 if(!isWasmInitialized) {
27189 throw new Error("initializeWasm() must be awaited first!");
27191 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
27192 // debug statements here
27194 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
27196 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
27197 if(!isWasmInitialized) {
27198 throw new Error("initializeWasm() must be awaited first!");
27200 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
27201 return nativeResponseValue;
27203 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
27205 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
27206 if(!isWasmInitialized) {
27207 throw new Error("initializeWasm() must be awaited first!");
27209 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
27210 // debug statements here
27212 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
27214 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
27215 if(!isWasmInitialized) {
27216 throw new Error("initializeWasm() must be awaited first!");
27218 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
27219 return nativeResponseValue;
27221 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
27223 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
27224 if(!isWasmInitialized) {
27225 throw new Error("initializeWasm() must be awaited first!");
27227 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
27228 // debug statements here
27230 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
27232 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
27233 if(!isWasmInitialized) {
27234 throw new Error("initializeWasm() must be awaited first!");
27236 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
27237 return nativeResponseValue;
27239 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
27241 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
27242 if(!isWasmInitialized) {
27243 throw new Error("initializeWasm() must be awaited first!");
27245 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
27246 // debug statements here
27248 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
27250 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
27251 if(!isWasmInitialized) {
27252 throw new Error("initializeWasm() must be awaited first!");
27254 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
27255 return nativeResponseValue;
27257 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
27259 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
27260 if(!isWasmInitialized) {
27261 throw new Error("initializeWasm() must be awaited first!");
27263 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
27264 // debug statements here
27266 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
27268 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
27269 if(!isWasmInitialized) {
27270 throw new Error("initializeWasm() must be awaited first!");
27272 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
27273 // debug statements here
27275 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
27277 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
27278 if(!isWasmInitialized) {
27279 throw new Error("initializeWasm() must be awaited first!");
27281 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
27282 return nativeResponseValue;
27284 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
27286 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
27287 if(!isWasmInitialized) {
27288 throw new Error("initializeWasm() must be awaited first!");
27290 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
27291 // debug statements here
27293 // 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);
27295 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 {
27296 if(!isWasmInitialized) {
27297 throw new Error("initializeWasm() must be awaited first!");
27299 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
27300 return nativeResponseValue;
27302 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
27304 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
27305 if(!isWasmInitialized) {
27306 throw new Error("initializeWasm() must be awaited first!");
27308 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
27309 return nativeResponseValue;
27311 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
27313 export function NodeAnnouncementInfo_clone(orig: number): number {
27314 if(!isWasmInitialized) {
27315 throw new Error("initializeWasm() must be awaited first!");
27317 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
27318 return nativeResponseValue;
27320 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
27322 export function NodeAnnouncementInfo_write(obj: number): number {
27323 if(!isWasmInitialized) {
27324 throw new Error("initializeWasm() must be awaited first!");
27326 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
27327 return nativeResponseValue;
27329 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
27331 export function NodeAnnouncementInfo_read(ser: number): number {
27332 if(!isWasmInitialized) {
27333 throw new Error("initializeWasm() must be awaited first!");
27335 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
27336 return nativeResponseValue;
27338 // void NodeInfo_free(struct LDKNodeInfo this_obj);
27340 export function NodeInfo_free(this_obj: number): void {
27341 if(!isWasmInitialized) {
27342 throw new Error("initializeWasm() must be awaited first!");
27344 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
27345 // debug statements here
27347 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
27349 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
27350 if(!isWasmInitialized) {
27351 throw new Error("initializeWasm() must be awaited first!");
27353 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
27354 // debug statements here
27356 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
27358 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
27359 if(!isWasmInitialized) {
27360 throw new Error("initializeWasm() must be awaited first!");
27362 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
27363 return nativeResponseValue;
27365 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
27367 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
27368 if(!isWasmInitialized) {
27369 throw new Error("initializeWasm() must be awaited first!");
27371 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
27372 // debug statements here
27374 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
27376 export function NodeInfo_get_announcement_info(this_ptr: number): number {
27377 if(!isWasmInitialized) {
27378 throw new Error("initializeWasm() must be awaited first!");
27380 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
27381 return nativeResponseValue;
27383 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
27385 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
27386 if(!isWasmInitialized) {
27387 throw new Error("initializeWasm() must be awaited first!");
27389 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
27390 // debug statements here
27392 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
27394 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
27395 if(!isWasmInitialized) {
27396 throw new Error("initializeWasm() must be awaited first!");
27398 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
27399 return nativeResponseValue;
27401 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
27403 export function NodeInfo_clone_ptr(arg: number): number {
27404 if(!isWasmInitialized) {
27405 throw new Error("initializeWasm() must be awaited first!");
27407 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
27408 return nativeResponseValue;
27410 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
27412 export function NodeInfo_clone(orig: number): number {
27413 if(!isWasmInitialized) {
27414 throw new Error("initializeWasm() must be awaited first!");
27416 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
27417 return nativeResponseValue;
27419 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
27421 export function NodeInfo_write(obj: number): number {
27422 if(!isWasmInitialized) {
27423 throw new Error("initializeWasm() must be awaited first!");
27425 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
27426 return nativeResponseValue;
27428 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
27430 export function NodeInfo_read(ser: number): number {
27431 if(!isWasmInitialized) {
27432 throw new Error("initializeWasm() must be awaited first!");
27434 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
27435 return nativeResponseValue;
27437 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
27439 export function NetworkGraph_write(obj: number): number {
27440 if(!isWasmInitialized) {
27441 throw new Error("initializeWasm() must be awaited first!");
27443 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
27444 return nativeResponseValue;
27446 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser);
27448 export function NetworkGraph_read(ser: number): number {
27449 if(!isWasmInitialized) {
27450 throw new Error("initializeWasm() must be awaited first!");
27452 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser);
27453 return nativeResponseValue;
27455 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash);
27457 export function NetworkGraph_new(genesis_hash: number): number {
27458 if(!isWasmInitialized) {
27459 throw new Error("initializeWasm() must be awaited first!");
27461 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash);
27462 return nativeResponseValue;
27464 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
27466 export function NetworkGraph_read_only(this_arg: number): number {
27467 if(!isWasmInitialized) {
27468 throw new Error("initializeWasm() must be awaited first!");
27470 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
27471 return nativeResponseValue;
27473 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
27475 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
27476 if(!isWasmInitialized) {
27477 throw new Error("initializeWasm() must be awaited first!");
27479 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
27480 return nativeResponseValue;
27482 // 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);
27484 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
27485 if(!isWasmInitialized) {
27486 throw new Error("initializeWasm() must be awaited first!");
27488 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
27489 return nativeResponseValue;
27491 // 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);
27493 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
27494 if(!isWasmInitialized) {
27495 throw new Error("initializeWasm() must be awaited first!");
27497 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
27498 return nativeResponseValue;
27500 // 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);
27502 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
27503 if(!isWasmInitialized) {
27504 throw new Error("initializeWasm() must be awaited first!");
27506 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
27507 return nativeResponseValue;
27509 // void NetworkGraph_close_channel_from_update(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
27511 export function NetworkGraph_close_channel_from_update(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
27512 if(!isWasmInitialized) {
27513 throw new Error("initializeWasm() must be awaited first!");
27515 const nativeResponseValue = wasm.TS_NetworkGraph_close_channel_from_update(this_arg, short_channel_id, is_permanent);
27516 // debug statements here
27518 // void NetworkGraph_fail_node(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
27520 export function NetworkGraph_fail_node(this_arg: number, _node_id: number, is_permanent: boolean): void {
27521 if(!isWasmInitialized) {
27522 throw new Error("initializeWasm() must be awaited first!");
27524 const nativeResponseValue = wasm.TS_NetworkGraph_fail_node(this_arg, _node_id, is_permanent);
27525 // debug statements here
27527 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
27529 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
27530 if(!isWasmInitialized) {
27531 throw new Error("initializeWasm() must be awaited first!");
27533 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
27534 // debug statements here
27536 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
27538 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
27539 if(!isWasmInitialized) {
27540 throw new Error("initializeWasm() must be awaited first!");
27542 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
27543 return nativeResponseValue;
27545 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
27547 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
27548 if(!isWasmInitialized) {
27549 throw new Error("initializeWasm() must be awaited first!");
27551 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
27552 return nativeResponseValue;
27554 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
27556 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
27557 if(!isWasmInitialized) {
27558 throw new Error("initializeWasm() must be awaited first!");
27560 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
27561 return nativeResponseValue;
27563 // void RouteHop_free(struct LDKRouteHop this_obj);
27565 export function RouteHop_free(this_obj: number): void {
27566 if(!isWasmInitialized) {
27567 throw new Error("initializeWasm() must be awaited first!");
27569 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
27570 // debug statements here
27572 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27574 export function RouteHop_get_pubkey(this_ptr: number): number {
27575 if(!isWasmInitialized) {
27576 throw new Error("initializeWasm() must be awaited first!");
27578 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
27579 return nativeResponseValue;
27581 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27583 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
27584 if(!isWasmInitialized) {
27585 throw new Error("initializeWasm() must be awaited first!");
27587 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
27588 // debug statements here
27590 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27592 export function RouteHop_get_node_features(this_ptr: number): number {
27593 if(!isWasmInitialized) {
27594 throw new Error("initializeWasm() must be awaited first!");
27596 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
27597 return nativeResponseValue;
27599 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
27601 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
27602 if(!isWasmInitialized) {
27603 throw new Error("initializeWasm() must be awaited first!");
27605 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
27606 // debug statements here
27608 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27610 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
27611 if(!isWasmInitialized) {
27612 throw new Error("initializeWasm() must be awaited first!");
27614 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
27615 return nativeResponseValue;
27617 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
27619 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
27620 if(!isWasmInitialized) {
27621 throw new Error("initializeWasm() must be awaited first!");
27623 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
27624 // debug statements here
27626 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27628 export function RouteHop_get_channel_features(this_ptr: number): number {
27629 if(!isWasmInitialized) {
27630 throw new Error("initializeWasm() must be awaited first!");
27632 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
27633 return nativeResponseValue;
27635 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
27637 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
27638 if(!isWasmInitialized) {
27639 throw new Error("initializeWasm() must be awaited first!");
27641 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
27642 // debug statements here
27644 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27646 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
27647 if(!isWasmInitialized) {
27648 throw new Error("initializeWasm() must be awaited first!");
27650 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
27651 return nativeResponseValue;
27653 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
27655 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
27656 if(!isWasmInitialized) {
27657 throw new Error("initializeWasm() must be awaited first!");
27659 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
27660 // debug statements here
27662 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
27664 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
27665 if(!isWasmInitialized) {
27666 throw new Error("initializeWasm() must be awaited first!");
27668 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
27669 return nativeResponseValue;
27671 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
27673 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
27674 if(!isWasmInitialized) {
27675 throw new Error("initializeWasm() must be awaited first!");
27677 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
27678 // debug statements here
27680 // 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);
27682 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 {
27683 if(!isWasmInitialized) {
27684 throw new Error("initializeWasm() must be awaited first!");
27686 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);
27687 return nativeResponseValue;
27689 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
27691 export function RouteHop_clone_ptr(arg: number): number {
27692 if(!isWasmInitialized) {
27693 throw new Error("initializeWasm() must be awaited first!");
27695 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
27696 return nativeResponseValue;
27698 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
27700 export function RouteHop_clone(orig: number): number {
27701 if(!isWasmInitialized) {
27702 throw new Error("initializeWasm() must be awaited first!");
27704 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
27705 return nativeResponseValue;
27707 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
27709 export function RouteHop_hash(o: number): bigint {
27710 if(!isWasmInitialized) {
27711 throw new Error("initializeWasm() must be awaited first!");
27713 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
27714 return nativeResponseValue;
27716 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
27718 export function RouteHop_eq(a: number, b: number): boolean {
27719 if(!isWasmInitialized) {
27720 throw new Error("initializeWasm() must be awaited first!");
27722 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
27723 return nativeResponseValue;
27725 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
27727 export function RouteHop_write(obj: number): number {
27728 if(!isWasmInitialized) {
27729 throw new Error("initializeWasm() must be awaited first!");
27731 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
27732 return nativeResponseValue;
27734 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
27736 export function RouteHop_read(ser: number): number {
27737 if(!isWasmInitialized) {
27738 throw new Error("initializeWasm() must be awaited first!");
27740 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
27741 return nativeResponseValue;
27743 // void Route_free(struct LDKRoute this_obj);
27745 export function Route_free(this_obj: number): void {
27746 if(!isWasmInitialized) {
27747 throw new Error("initializeWasm() must be awaited first!");
27749 const nativeResponseValue = wasm.TS_Route_free(this_obj);
27750 // debug statements here
27752 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
27754 export function Route_get_paths(this_ptr: number): number {
27755 if(!isWasmInitialized) {
27756 throw new Error("initializeWasm() must be awaited first!");
27758 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
27759 return nativeResponseValue;
27761 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
27763 export function Route_set_paths(this_ptr: number, val: number): void {
27764 if(!isWasmInitialized) {
27765 throw new Error("initializeWasm() must be awaited first!");
27767 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
27768 // debug statements here
27770 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
27772 export function Route_get_payment_params(this_ptr: number): number {
27773 if(!isWasmInitialized) {
27774 throw new Error("initializeWasm() must be awaited first!");
27776 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
27777 return nativeResponseValue;
27779 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
27781 export function Route_set_payment_params(this_ptr: number, val: number): void {
27782 if(!isWasmInitialized) {
27783 throw new Error("initializeWasm() must be awaited first!");
27785 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
27786 // debug statements here
27788 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
27790 export function Route_new(paths_arg: number, payment_params_arg: number): number {
27791 if(!isWasmInitialized) {
27792 throw new Error("initializeWasm() must be awaited first!");
27794 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
27795 return nativeResponseValue;
27797 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
27799 export function Route_clone_ptr(arg: number): number {
27800 if(!isWasmInitialized) {
27801 throw new Error("initializeWasm() must be awaited first!");
27803 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
27804 return nativeResponseValue;
27806 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
27808 export function Route_clone(orig: number): number {
27809 if(!isWasmInitialized) {
27810 throw new Error("initializeWasm() must be awaited first!");
27812 const nativeResponseValue = wasm.TS_Route_clone(orig);
27813 return nativeResponseValue;
27815 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
27817 export function Route_hash(o: number): bigint {
27818 if(!isWasmInitialized) {
27819 throw new Error("initializeWasm() must be awaited first!");
27821 const nativeResponseValue = wasm.TS_Route_hash(o);
27822 return nativeResponseValue;
27824 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
27826 export function Route_eq(a: number, b: number): boolean {
27827 if(!isWasmInitialized) {
27828 throw new Error("initializeWasm() must be awaited first!");
27830 const nativeResponseValue = wasm.TS_Route_eq(a, b);
27831 return nativeResponseValue;
27833 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
27835 export function Route_get_total_fees(this_arg: number): bigint {
27836 if(!isWasmInitialized) {
27837 throw new Error("initializeWasm() must be awaited first!");
27839 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
27840 return nativeResponseValue;
27842 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
27844 export function Route_get_total_amount(this_arg: number): bigint {
27845 if(!isWasmInitialized) {
27846 throw new Error("initializeWasm() must be awaited first!");
27848 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
27849 return nativeResponseValue;
27851 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
27853 export function Route_write(obj: number): number {
27854 if(!isWasmInitialized) {
27855 throw new Error("initializeWasm() must be awaited first!");
27857 const nativeResponseValue = wasm.TS_Route_write(obj);
27858 return nativeResponseValue;
27860 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
27862 export function Route_read(ser: number): number {
27863 if(!isWasmInitialized) {
27864 throw new Error("initializeWasm() must be awaited first!");
27866 const nativeResponseValue = wasm.TS_Route_read(ser);
27867 return nativeResponseValue;
27869 // void RouteParameters_free(struct LDKRouteParameters this_obj);
27871 export function RouteParameters_free(this_obj: number): void {
27872 if(!isWasmInitialized) {
27873 throw new Error("initializeWasm() must be awaited first!");
27875 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
27876 // debug statements here
27878 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27880 export function RouteParameters_get_payment_params(this_ptr: number): number {
27881 if(!isWasmInitialized) {
27882 throw new Error("initializeWasm() must be awaited first!");
27884 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
27885 return nativeResponseValue;
27887 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
27889 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
27890 if(!isWasmInitialized) {
27891 throw new Error("initializeWasm() must be awaited first!");
27893 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
27894 // debug statements here
27896 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27898 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
27899 if(!isWasmInitialized) {
27900 throw new Error("initializeWasm() must be awaited first!");
27902 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
27903 return nativeResponseValue;
27905 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
27907 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
27908 if(!isWasmInitialized) {
27909 throw new Error("initializeWasm() must be awaited first!");
27911 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
27912 // debug statements here
27914 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
27916 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
27917 if(!isWasmInitialized) {
27918 throw new Error("initializeWasm() must be awaited first!");
27920 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
27921 return nativeResponseValue;
27923 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
27925 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
27926 if(!isWasmInitialized) {
27927 throw new Error("initializeWasm() must be awaited first!");
27929 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
27930 // debug statements here
27932 // 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);
27934 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
27935 if(!isWasmInitialized) {
27936 throw new Error("initializeWasm() must be awaited first!");
27938 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
27939 return nativeResponseValue;
27941 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
27943 export function RouteParameters_clone_ptr(arg: number): number {
27944 if(!isWasmInitialized) {
27945 throw new Error("initializeWasm() must be awaited first!");
27947 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
27948 return nativeResponseValue;
27950 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
27952 export function RouteParameters_clone(orig: number): number {
27953 if(!isWasmInitialized) {
27954 throw new Error("initializeWasm() must be awaited first!");
27956 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
27957 return nativeResponseValue;
27959 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
27961 export function RouteParameters_write(obj: number): number {
27962 if(!isWasmInitialized) {
27963 throw new Error("initializeWasm() must be awaited first!");
27965 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
27966 return nativeResponseValue;
27968 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
27970 export function RouteParameters_read(ser: number): number {
27971 if(!isWasmInitialized) {
27972 throw new Error("initializeWasm() must be awaited first!");
27974 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
27975 return nativeResponseValue;
27977 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
27979 export function PaymentParameters_free(this_obj: number): void {
27980 if(!isWasmInitialized) {
27981 throw new Error("initializeWasm() must be awaited first!");
27983 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
27984 // debug statements here
27986 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
27988 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
27989 if(!isWasmInitialized) {
27990 throw new Error("initializeWasm() must be awaited first!");
27992 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
27993 return nativeResponseValue;
27995 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
27997 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
27998 if(!isWasmInitialized) {
27999 throw new Error("initializeWasm() must be awaited first!");
28001 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
28002 // debug statements here
28004 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
28006 export function PaymentParameters_get_features(this_ptr: number): number {
28007 if(!isWasmInitialized) {
28008 throw new Error("initializeWasm() must be awaited first!");
28010 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
28011 return nativeResponseValue;
28013 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
28015 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
28016 if(!isWasmInitialized) {
28017 throw new Error("initializeWasm() must be awaited first!");
28019 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
28020 // debug statements here
28022 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
28024 export function PaymentParameters_get_route_hints(this_ptr: number): number {
28025 if(!isWasmInitialized) {
28026 throw new Error("initializeWasm() must be awaited first!");
28028 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
28029 return nativeResponseValue;
28031 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
28033 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
28034 if(!isWasmInitialized) {
28035 throw new Error("initializeWasm() must be awaited first!");
28037 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
28038 // debug statements here
28040 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
28042 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
28043 if(!isWasmInitialized) {
28044 throw new Error("initializeWasm() must be awaited first!");
28046 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
28047 return nativeResponseValue;
28049 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28051 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
28052 if(!isWasmInitialized) {
28053 throw new Error("initializeWasm() must be awaited first!");
28055 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
28056 // debug statements here
28058 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
28060 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
28061 if(!isWasmInitialized) {
28062 throw new Error("initializeWasm() must be awaited first!");
28064 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
28065 return nativeResponseValue;
28067 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
28069 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
28070 if(!isWasmInitialized) {
28071 throw new Error("initializeWasm() must be awaited first!");
28073 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
28074 // debug statements here
28076 // 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);
28078 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 {
28079 if(!isWasmInitialized) {
28080 throw new Error("initializeWasm() must be awaited first!");
28082 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg);
28083 return nativeResponseValue;
28085 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
28087 export function PaymentParameters_clone_ptr(arg: number): number {
28088 if(!isWasmInitialized) {
28089 throw new Error("initializeWasm() must be awaited first!");
28091 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
28092 return nativeResponseValue;
28094 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
28096 export function PaymentParameters_clone(orig: number): number {
28097 if(!isWasmInitialized) {
28098 throw new Error("initializeWasm() must be awaited first!");
28100 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
28101 return nativeResponseValue;
28103 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
28105 export function PaymentParameters_hash(o: number): bigint {
28106 if(!isWasmInitialized) {
28107 throw new Error("initializeWasm() must be awaited first!");
28109 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
28110 return nativeResponseValue;
28112 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
28114 export function PaymentParameters_eq(a: number, b: number): boolean {
28115 if(!isWasmInitialized) {
28116 throw new Error("initializeWasm() must be awaited first!");
28118 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
28119 return nativeResponseValue;
28121 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
28123 export function PaymentParameters_write(obj: number): number {
28124 if(!isWasmInitialized) {
28125 throw new Error("initializeWasm() must be awaited first!");
28127 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
28128 return nativeResponseValue;
28130 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
28132 export function PaymentParameters_read(ser: number): number {
28133 if(!isWasmInitialized) {
28134 throw new Error("initializeWasm() must be awaited first!");
28136 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
28137 return nativeResponseValue;
28139 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
28141 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
28142 if(!isWasmInitialized) {
28143 throw new Error("initializeWasm() must be awaited first!");
28145 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
28146 return nativeResponseValue;
28148 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
28150 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
28151 if(!isWasmInitialized) {
28152 throw new Error("initializeWasm() must be awaited first!");
28154 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
28155 return nativeResponseValue;
28157 // void RouteHint_free(struct LDKRouteHint this_obj);
28159 export function RouteHint_free(this_obj: number): void {
28160 if(!isWasmInitialized) {
28161 throw new Error("initializeWasm() must be awaited first!");
28163 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
28164 // debug statements here
28166 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
28168 export function RouteHint_get_a(this_ptr: number): number {
28169 if(!isWasmInitialized) {
28170 throw new Error("initializeWasm() must be awaited first!");
28172 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
28173 return nativeResponseValue;
28175 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
28177 export function RouteHint_set_a(this_ptr: number, val: number): void {
28178 if(!isWasmInitialized) {
28179 throw new Error("initializeWasm() must be awaited first!");
28181 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
28182 // debug statements here
28184 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
28186 export function RouteHint_new(a_arg: number): number {
28187 if(!isWasmInitialized) {
28188 throw new Error("initializeWasm() must be awaited first!");
28190 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
28191 return nativeResponseValue;
28193 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
28195 export function RouteHint_clone_ptr(arg: number): number {
28196 if(!isWasmInitialized) {
28197 throw new Error("initializeWasm() must be awaited first!");
28199 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
28200 return nativeResponseValue;
28202 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
28204 export function RouteHint_clone(orig: number): number {
28205 if(!isWasmInitialized) {
28206 throw new Error("initializeWasm() must be awaited first!");
28208 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
28209 return nativeResponseValue;
28211 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
28213 export function RouteHint_hash(o: number): bigint {
28214 if(!isWasmInitialized) {
28215 throw new Error("initializeWasm() must be awaited first!");
28217 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
28218 return nativeResponseValue;
28220 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
28222 export function RouteHint_eq(a: number, b: number): boolean {
28223 if(!isWasmInitialized) {
28224 throw new Error("initializeWasm() must be awaited first!");
28226 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
28227 return nativeResponseValue;
28229 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
28231 export function RouteHint_write(obj: number): number {
28232 if(!isWasmInitialized) {
28233 throw new Error("initializeWasm() must be awaited first!");
28235 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
28236 return nativeResponseValue;
28238 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
28240 export function RouteHint_read(ser: number): number {
28241 if(!isWasmInitialized) {
28242 throw new Error("initializeWasm() must be awaited first!");
28244 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
28245 return nativeResponseValue;
28247 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
28249 export function RouteHintHop_free(this_obj: number): void {
28250 if(!isWasmInitialized) {
28251 throw new Error("initializeWasm() must be awaited first!");
28253 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
28254 // debug statements here
28256 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28258 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
28259 if(!isWasmInitialized) {
28260 throw new Error("initializeWasm() must be awaited first!");
28262 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
28263 return nativeResponseValue;
28265 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
28267 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
28268 if(!isWasmInitialized) {
28269 throw new Error("initializeWasm() must be awaited first!");
28271 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
28272 // debug statements here
28274 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28276 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
28277 if(!isWasmInitialized) {
28278 throw new Error("initializeWasm() must be awaited first!");
28280 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
28281 return nativeResponseValue;
28283 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
28285 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
28286 if(!isWasmInitialized) {
28287 throw new Error("initializeWasm() must be awaited first!");
28289 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
28290 // debug statements here
28292 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28294 export function RouteHintHop_get_fees(this_ptr: number): number {
28295 if(!isWasmInitialized) {
28296 throw new Error("initializeWasm() must be awaited first!");
28298 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
28299 return nativeResponseValue;
28301 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
28303 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
28304 if(!isWasmInitialized) {
28305 throw new Error("initializeWasm() must be awaited first!");
28307 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
28308 // debug statements here
28310 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28312 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
28313 if(!isWasmInitialized) {
28314 throw new Error("initializeWasm() must be awaited first!");
28316 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
28317 return nativeResponseValue;
28319 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
28321 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28322 if(!isWasmInitialized) {
28323 throw new Error("initializeWasm() must be awaited first!");
28325 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
28326 // debug statements here
28328 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28330 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
28331 if(!isWasmInitialized) {
28332 throw new Error("initializeWasm() must be awaited first!");
28334 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
28335 return nativeResponseValue;
28337 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28339 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
28340 if(!isWasmInitialized) {
28341 throw new Error("initializeWasm() must be awaited first!");
28343 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
28344 // debug statements here
28346 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
28348 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
28349 if(!isWasmInitialized) {
28350 throw new Error("initializeWasm() must be awaited first!");
28352 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
28353 return nativeResponseValue;
28355 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28357 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28358 if(!isWasmInitialized) {
28359 throw new Error("initializeWasm() must be awaited first!");
28361 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
28362 // debug statements here
28364 // 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);
28366 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 {
28367 if(!isWasmInitialized) {
28368 throw new Error("initializeWasm() must be awaited first!");
28370 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);
28371 return nativeResponseValue;
28373 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
28375 export function RouteHintHop_clone_ptr(arg: number): number {
28376 if(!isWasmInitialized) {
28377 throw new Error("initializeWasm() must be awaited first!");
28379 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
28380 return nativeResponseValue;
28382 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
28384 export function RouteHintHop_clone(orig: number): number {
28385 if(!isWasmInitialized) {
28386 throw new Error("initializeWasm() must be awaited first!");
28388 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
28389 return nativeResponseValue;
28391 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
28393 export function RouteHintHop_hash(o: number): bigint {
28394 if(!isWasmInitialized) {
28395 throw new Error("initializeWasm() must be awaited first!");
28397 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
28398 return nativeResponseValue;
28400 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
28402 export function RouteHintHop_eq(a: number, b: number): boolean {
28403 if(!isWasmInitialized) {
28404 throw new Error("initializeWasm() must be awaited first!");
28406 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
28407 return nativeResponseValue;
28409 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
28411 export function RouteHintHop_write(obj: number): number {
28412 if(!isWasmInitialized) {
28413 throw new Error("initializeWasm() must be awaited first!");
28415 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
28416 return nativeResponseValue;
28418 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
28420 export function RouteHintHop_read(ser: number): number {
28421 if(!isWasmInitialized) {
28422 throw new Error("initializeWasm() must be awaited first!");
28424 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
28425 return nativeResponseValue;
28427 // struct LDKCResult_RouteLightningErrorZ find_route(struct LDKPublicKey our_node_pubkey, const struct LDKRouteParameters *NONNULL_PTR route_params, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKLogger logger, const struct LDKScore *NONNULL_PTR scorer, const uint8_t (*random_seed_bytes)[32]);
28429 export function find_route(our_node_pubkey: number, route_params: number, network: number, first_hops: number, logger: number, scorer: number, random_seed_bytes: number): number {
28430 if(!isWasmInitialized) {
28431 throw new Error("initializeWasm() must be awaited first!");
28433 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network, first_hops, logger, scorer, random_seed_bytes);
28434 return nativeResponseValue;
28436 // void Score_free(struct LDKScore this_ptr);
28438 export function Score_free(this_ptr: number): void {
28439 if(!isWasmInitialized) {
28440 throw new Error("initializeWasm() must be awaited first!");
28442 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
28443 // debug statements here
28445 // void LockableScore_free(struct LDKLockableScore this_ptr);
28447 export function LockableScore_free(this_ptr: number): void {
28448 if(!isWasmInitialized) {
28449 throw new Error("initializeWasm() must be awaited first!");
28451 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
28452 // debug statements here
28454 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
28456 export function MultiThreadedLockableScore_free(this_obj: number): void {
28457 if(!isWasmInitialized) {
28458 throw new Error("initializeWasm() must be awaited first!");
28460 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
28461 // debug statements here
28463 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
28465 export function MultiThreadedLockableScore_new(score: number): number {
28466 if(!isWasmInitialized) {
28467 throw new Error("initializeWasm() must be awaited first!");
28469 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
28470 return nativeResponseValue;
28472 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
28474 export function FixedPenaltyScorer_free(this_obj: number): void {
28475 if(!isWasmInitialized) {
28476 throw new Error("initializeWasm() must be awaited first!");
28478 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
28479 // debug statements here
28481 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
28483 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
28484 if(!isWasmInitialized) {
28485 throw new Error("initializeWasm() must be awaited first!");
28487 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
28488 return nativeResponseValue;
28490 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
28492 export function FixedPenaltyScorer_clone(orig: number): number {
28493 if(!isWasmInitialized) {
28494 throw new Error("initializeWasm() must be awaited first!");
28496 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
28497 return nativeResponseValue;
28499 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
28501 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
28502 if(!isWasmInitialized) {
28503 throw new Error("initializeWasm() must be awaited first!");
28505 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
28506 return nativeResponseValue;
28508 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
28510 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
28511 if(!isWasmInitialized) {
28512 throw new Error("initializeWasm() must be awaited first!");
28514 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
28515 return nativeResponseValue;
28517 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
28519 export function FixedPenaltyScorer_write(obj: number): number {
28520 if(!isWasmInitialized) {
28521 throw new Error("initializeWasm() must be awaited first!");
28523 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
28524 return nativeResponseValue;
28526 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
28528 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
28529 if(!isWasmInitialized) {
28530 throw new Error("initializeWasm() must be awaited first!");
28532 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
28533 return nativeResponseValue;
28535 // void Scorer_free(struct LDKScorer this_obj);
28537 export function Scorer_free(this_obj: number): void {
28538 if(!isWasmInitialized) {
28539 throw new Error("initializeWasm() must be awaited first!");
28541 const nativeResponseValue = wasm.TS_Scorer_free(this_obj);
28542 // debug statements here
28544 // void ScoringParameters_free(struct LDKScoringParameters this_obj);
28546 export function ScoringParameters_free(this_obj: number): void {
28547 if(!isWasmInitialized) {
28548 throw new Error("initializeWasm() must be awaited first!");
28550 const nativeResponseValue = wasm.TS_ScoringParameters_free(this_obj);
28551 // debug statements here
28553 // uint64_t ScoringParameters_get_base_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28555 export function ScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
28556 if(!isWasmInitialized) {
28557 throw new Error("initializeWasm() must be awaited first!");
28559 const nativeResponseValue = wasm.TS_ScoringParameters_get_base_penalty_msat(this_ptr);
28560 return nativeResponseValue;
28562 // void ScoringParameters_set_base_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28564 export function ScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
28565 if(!isWasmInitialized) {
28566 throw new Error("initializeWasm() must be awaited first!");
28568 const nativeResponseValue = wasm.TS_ScoringParameters_set_base_penalty_msat(this_ptr, val);
28569 // debug statements here
28571 // uint64_t ScoringParameters_get_failure_penalty_msat(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28573 export function ScoringParameters_get_failure_penalty_msat(this_ptr: number): bigint {
28574 if(!isWasmInitialized) {
28575 throw new Error("initializeWasm() must be awaited first!");
28577 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_msat(this_ptr);
28578 return nativeResponseValue;
28580 // void ScoringParameters_set_failure_penalty_msat(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28582 export function ScoringParameters_set_failure_penalty_msat(this_ptr: number, val: bigint): void {
28583 if(!isWasmInitialized) {
28584 throw new Error("initializeWasm() must be awaited first!");
28586 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_msat(this_ptr, val);
28587 // debug statements here
28589 // uint16_t ScoringParameters_get_overuse_penalty_start_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28591 export function ScoringParameters_get_overuse_penalty_start_1024th(this_ptr: number): number {
28592 if(!isWasmInitialized) {
28593 throw new Error("initializeWasm() must be awaited first!");
28595 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_start_1024th(this_ptr);
28596 return nativeResponseValue;
28598 // void ScoringParameters_set_overuse_penalty_start_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint16_t val);
28600 export function ScoringParameters_set_overuse_penalty_start_1024th(this_ptr: number, val: number): void {
28601 if(!isWasmInitialized) {
28602 throw new Error("initializeWasm() must be awaited first!");
28604 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_start_1024th(this_ptr, val);
28605 // debug statements here
28607 // uint64_t ScoringParameters_get_overuse_penalty_msat_per_1024th(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28609 export function ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr: number): bigint {
28610 if(!isWasmInitialized) {
28611 throw new Error("initializeWasm() must be awaited first!");
28613 const nativeResponseValue = wasm.TS_ScoringParameters_get_overuse_penalty_msat_per_1024th(this_ptr);
28614 return nativeResponseValue;
28616 // void ScoringParameters_set_overuse_penalty_msat_per_1024th(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28618 export function ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr: number, val: bigint): void {
28619 if(!isWasmInitialized) {
28620 throw new Error("initializeWasm() must be awaited first!");
28622 const nativeResponseValue = wasm.TS_ScoringParameters_set_overuse_penalty_msat_per_1024th(this_ptr, val);
28623 // debug statements here
28625 // uint64_t ScoringParameters_get_failure_penalty_half_life(const struct LDKScoringParameters *NONNULL_PTR this_ptr);
28627 export function ScoringParameters_get_failure_penalty_half_life(this_ptr: number): bigint {
28628 if(!isWasmInitialized) {
28629 throw new Error("initializeWasm() must be awaited first!");
28631 const nativeResponseValue = wasm.TS_ScoringParameters_get_failure_penalty_half_life(this_ptr);
28632 return nativeResponseValue;
28634 // void ScoringParameters_set_failure_penalty_half_life(struct LDKScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28636 export function ScoringParameters_set_failure_penalty_half_life(this_ptr: number, val: bigint): void {
28637 if(!isWasmInitialized) {
28638 throw new Error("initializeWasm() must be awaited first!");
28640 const nativeResponseValue = wasm.TS_ScoringParameters_set_failure_penalty_half_life(this_ptr, val);
28641 // debug statements here
28643 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_new(uint64_t base_penalty_msat_arg, uint64_t failure_penalty_msat_arg, uint16_t overuse_penalty_start_1024th_arg, uint64_t overuse_penalty_msat_per_1024th_arg, uint64_t failure_penalty_half_life_arg);
28645 export function ScoringParameters_new(base_penalty_msat_arg: bigint, failure_penalty_msat_arg: bigint, overuse_penalty_start_1024th_arg: number, overuse_penalty_msat_per_1024th_arg: bigint, failure_penalty_half_life_arg: bigint): number {
28646 if(!isWasmInitialized) {
28647 throw new Error("initializeWasm() must be awaited first!");
28649 const nativeResponseValue = wasm.TS_ScoringParameters_new(base_penalty_msat_arg, failure_penalty_msat_arg, overuse_penalty_start_1024th_arg, overuse_penalty_msat_per_1024th_arg, failure_penalty_half_life_arg);
28650 return nativeResponseValue;
28652 // uintptr_t ScoringParameters_clone_ptr(LDKScoringParameters *NONNULL_PTR arg);
28654 export function ScoringParameters_clone_ptr(arg: number): number {
28655 if(!isWasmInitialized) {
28656 throw new Error("initializeWasm() must be awaited first!");
28658 const nativeResponseValue = wasm.TS_ScoringParameters_clone_ptr(arg);
28659 return nativeResponseValue;
28661 // struct LDKScoringParameters ScoringParameters_clone(const struct LDKScoringParameters *NONNULL_PTR orig);
28663 export function ScoringParameters_clone(orig: number): number {
28664 if(!isWasmInitialized) {
28665 throw new Error("initializeWasm() must be awaited first!");
28667 const nativeResponseValue = wasm.TS_ScoringParameters_clone(orig);
28668 return nativeResponseValue;
28670 // struct LDKCVec_u8Z ScoringParameters_write(const struct LDKScoringParameters *NONNULL_PTR obj);
28672 export function ScoringParameters_write(obj: number): number {
28673 if(!isWasmInitialized) {
28674 throw new Error("initializeWasm() must be awaited first!");
28676 const nativeResponseValue = wasm.TS_ScoringParameters_write(obj);
28677 return nativeResponseValue;
28679 // struct LDKCResult_ScoringParametersDecodeErrorZ ScoringParameters_read(struct LDKu8slice ser);
28681 export function ScoringParameters_read(ser: number): number {
28682 if(!isWasmInitialized) {
28683 throw new Error("initializeWasm() must be awaited first!");
28685 const nativeResponseValue = wasm.TS_ScoringParameters_read(ser);
28686 return nativeResponseValue;
28688 // MUST_USE_RES struct LDKScorer Scorer_new(struct LDKScoringParameters params);
28690 export function Scorer_new(params: number): number {
28691 if(!isWasmInitialized) {
28692 throw new Error("initializeWasm() must be awaited first!");
28694 const nativeResponseValue = wasm.TS_Scorer_new(params);
28695 return nativeResponseValue;
28697 // MUST_USE_RES struct LDKScorer Scorer_default(void);
28699 export function Scorer_default(): number {
28700 if(!isWasmInitialized) {
28701 throw new Error("initializeWasm() must be awaited first!");
28703 const nativeResponseValue = wasm.TS_Scorer_default();
28704 return nativeResponseValue;
28706 // MUST_USE_RES struct LDKScoringParameters ScoringParameters_default(void);
28708 export function ScoringParameters_default(): number {
28709 if(!isWasmInitialized) {
28710 throw new Error("initializeWasm() must be awaited first!");
28712 const nativeResponseValue = wasm.TS_ScoringParameters_default();
28713 return nativeResponseValue;
28715 // struct LDKScore Scorer_as_Score(const struct LDKScorer *NONNULL_PTR this_arg);
28717 export function Scorer_as_Score(this_arg: number): number {
28718 if(!isWasmInitialized) {
28719 throw new Error("initializeWasm() must be awaited first!");
28721 const nativeResponseValue = wasm.TS_Scorer_as_Score(this_arg);
28722 return nativeResponseValue;
28724 // struct LDKCVec_u8Z Scorer_write(const struct LDKScorer *NONNULL_PTR obj);
28726 export function Scorer_write(obj: number): number {
28727 if(!isWasmInitialized) {
28728 throw new Error("initializeWasm() must be awaited first!");
28730 const nativeResponseValue = wasm.TS_Scorer_write(obj);
28731 return nativeResponseValue;
28733 // struct LDKCResult_ScorerDecodeErrorZ Scorer_read(struct LDKu8slice ser);
28735 export function Scorer_read(ser: number): number {
28736 if(!isWasmInitialized) {
28737 throw new Error("initializeWasm() must be awaited first!");
28739 const nativeResponseValue = wasm.TS_Scorer_read(ser);
28740 return nativeResponseValue;
28742 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
28744 export function ProbabilisticScorer_free(this_obj: number): void {
28745 if(!isWasmInitialized) {
28746 throw new Error("initializeWasm() must be awaited first!");
28748 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
28749 // debug statements here
28751 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
28753 export function ProbabilisticScoringParameters_free(this_obj: number): void {
28754 if(!isWasmInitialized) {
28755 throw new Error("initializeWasm() must be awaited first!");
28757 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
28758 // debug statements here
28760 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28762 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
28763 if(!isWasmInitialized) {
28764 throw new Error("initializeWasm() must be awaited first!");
28766 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
28767 return nativeResponseValue;
28769 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28771 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
28772 if(!isWasmInitialized) {
28773 throw new Error("initializeWasm() must be awaited first!");
28775 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
28776 // debug statements here
28778 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28780 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
28781 if(!isWasmInitialized) {
28782 throw new Error("initializeWasm() must be awaited first!");
28784 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
28785 return nativeResponseValue;
28787 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28789 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
28790 if(!isWasmInitialized) {
28791 throw new Error("initializeWasm() must be awaited first!");
28793 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
28794 // debug statements here
28796 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28798 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
28799 if(!isWasmInitialized) {
28800 throw new Error("initializeWasm() must be awaited first!");
28802 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
28803 return nativeResponseValue;
28805 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28807 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
28808 if(!isWasmInitialized) {
28809 throw new Error("initializeWasm() must be awaited first!");
28811 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
28812 // debug statements here
28814 // uint64_t ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
28816 export function ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr: number): bigint {
28817 if(!isWasmInitialized) {
28818 throw new Error("initializeWasm() must be awaited first!");
28820 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr);
28821 return nativeResponseValue;
28823 // void ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
28825 export function ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
28826 if(!isWasmInitialized) {
28827 throw new Error("initializeWasm() must be awaited first!");
28829 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr, val);
28830 // debug statements here
28832 // 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);
28834 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 {
28835 if(!isWasmInitialized) {
28836 throw new Error("initializeWasm() must be awaited first!");
28838 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);
28839 return nativeResponseValue;
28841 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
28843 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
28844 if(!isWasmInitialized) {
28845 throw new Error("initializeWasm() must be awaited first!");
28847 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
28848 return nativeResponseValue;
28850 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
28852 export function ProbabilisticScoringParameters_clone(orig: number): number {
28853 if(!isWasmInitialized) {
28854 throw new Error("initializeWasm() must be awaited first!");
28856 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
28857 return nativeResponseValue;
28859 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph);
28861 export function ProbabilisticScorer_new(params: number, network_graph: number): number {
28862 if(!isWasmInitialized) {
28863 throw new Error("initializeWasm() must be awaited first!");
28865 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph);
28866 return nativeResponseValue;
28868 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
28870 export function ProbabilisticScoringParameters_default(): number {
28871 if(!isWasmInitialized) {
28872 throw new Error("initializeWasm() must be awaited first!");
28874 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
28875 return nativeResponseValue;
28877 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
28879 export function ProbabilisticScorer_as_Score(this_arg: number): number {
28880 if(!isWasmInitialized) {
28881 throw new Error("initializeWasm() must be awaited first!");
28883 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
28884 return nativeResponseValue;
28886 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
28888 export function ProbabilisticScorer_write(obj: number): number {
28889 if(!isWasmInitialized) {
28890 throw new Error("initializeWasm() must be awaited first!");
28892 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
28893 return nativeResponseValue;
28895 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b);
28897 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number): number {
28898 if(!isWasmInitialized) {
28899 throw new Error("initializeWasm() must be awaited first!");
28901 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b);
28902 return nativeResponseValue;
28904 // void ParseError_free(struct LDKParseError this_ptr);
28906 export function ParseError_free(this_ptr: number): void {
28907 if(!isWasmInitialized) {
28908 throw new Error("initializeWasm() must be awaited first!");
28910 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
28911 // debug statements here
28913 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
28915 export function ParseError_clone_ptr(arg: number): number {
28916 if(!isWasmInitialized) {
28917 throw new Error("initializeWasm() must be awaited first!");
28919 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
28920 return nativeResponseValue;
28922 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
28924 export function ParseError_clone(orig: number): number {
28925 if(!isWasmInitialized) {
28926 throw new Error("initializeWasm() must be awaited first!");
28928 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
28929 return nativeResponseValue;
28931 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
28933 export function ParseError_bech32_error(a: number): number {
28934 if(!isWasmInitialized) {
28935 throw new Error("initializeWasm() must be awaited first!");
28937 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
28938 return nativeResponseValue;
28940 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
28942 export function ParseError_parse_amount_error(a: number): number {
28943 if(!isWasmInitialized) {
28944 throw new Error("initializeWasm() must be awaited first!");
28946 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
28947 return nativeResponseValue;
28949 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
28951 export function ParseError_malformed_signature(a: Secp256k1Error): number {
28952 if(!isWasmInitialized) {
28953 throw new Error("initializeWasm() must be awaited first!");
28955 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
28956 return nativeResponseValue;
28958 // struct LDKParseError ParseError_bad_prefix(void);
28960 export function ParseError_bad_prefix(): number {
28961 if(!isWasmInitialized) {
28962 throw new Error("initializeWasm() must be awaited first!");
28964 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
28965 return nativeResponseValue;
28967 // struct LDKParseError ParseError_unknown_currency(void);
28969 export function ParseError_unknown_currency(): number {
28970 if(!isWasmInitialized) {
28971 throw new Error("initializeWasm() must be awaited first!");
28973 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
28974 return nativeResponseValue;
28976 // struct LDKParseError ParseError_unknown_si_prefix(void);
28978 export function ParseError_unknown_si_prefix(): number {
28979 if(!isWasmInitialized) {
28980 throw new Error("initializeWasm() must be awaited first!");
28982 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
28983 return nativeResponseValue;
28985 // struct LDKParseError ParseError_malformed_hrp(void);
28987 export function ParseError_malformed_hrp(): number {
28988 if(!isWasmInitialized) {
28989 throw new Error("initializeWasm() must be awaited first!");
28991 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
28992 return nativeResponseValue;
28994 // struct LDKParseError ParseError_too_short_data_part(void);
28996 export function ParseError_too_short_data_part(): number {
28997 if(!isWasmInitialized) {
28998 throw new Error("initializeWasm() must be awaited first!");
29000 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
29001 return nativeResponseValue;
29003 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
29005 export function ParseError_unexpected_end_of_tagged_fields(): number {
29006 if(!isWasmInitialized) {
29007 throw new Error("initializeWasm() must be awaited first!");
29009 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
29010 return nativeResponseValue;
29012 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
29014 export function ParseError_description_decode_error(a: number): number {
29015 if(!isWasmInitialized) {
29016 throw new Error("initializeWasm() must be awaited first!");
29018 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
29019 return nativeResponseValue;
29021 // struct LDKParseError ParseError_padding_error(void);
29023 export function ParseError_padding_error(): number {
29024 if(!isWasmInitialized) {
29025 throw new Error("initializeWasm() must be awaited first!");
29027 const nativeResponseValue = wasm.TS_ParseError_padding_error();
29028 return nativeResponseValue;
29030 // struct LDKParseError ParseError_integer_overflow_error(void);
29032 export function ParseError_integer_overflow_error(): number {
29033 if(!isWasmInitialized) {
29034 throw new Error("initializeWasm() must be awaited first!");
29036 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
29037 return nativeResponseValue;
29039 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
29041 export function ParseError_invalid_seg_wit_program_length(): number {
29042 if(!isWasmInitialized) {
29043 throw new Error("initializeWasm() must be awaited first!");
29045 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
29046 return nativeResponseValue;
29048 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
29050 export function ParseError_invalid_pub_key_hash_length(): number {
29051 if(!isWasmInitialized) {
29052 throw new Error("initializeWasm() must be awaited first!");
29054 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
29055 return nativeResponseValue;
29057 // struct LDKParseError ParseError_invalid_script_hash_length(void);
29059 export function ParseError_invalid_script_hash_length(): number {
29060 if(!isWasmInitialized) {
29061 throw new Error("initializeWasm() must be awaited first!");
29063 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
29064 return nativeResponseValue;
29066 // struct LDKParseError ParseError_invalid_recovery_id(void);
29068 export function ParseError_invalid_recovery_id(): number {
29069 if(!isWasmInitialized) {
29070 throw new Error("initializeWasm() must be awaited first!");
29072 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
29073 return nativeResponseValue;
29075 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
29077 export function ParseError_invalid_slice_length(a: number): number {
29078 if(!isWasmInitialized) {
29079 throw new Error("initializeWasm() must be awaited first!");
29081 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
29082 return nativeResponseValue;
29084 // struct LDKParseError ParseError_skip(void);
29086 export function ParseError_skip(): number {
29087 if(!isWasmInitialized) {
29088 throw new Error("initializeWasm() must be awaited first!");
29090 const nativeResponseValue = wasm.TS_ParseError_skip();
29091 return nativeResponseValue;
29093 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
29095 export function ParseOrSemanticError_free(this_ptr: number): void {
29096 if(!isWasmInitialized) {
29097 throw new Error("initializeWasm() must be awaited first!");
29099 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
29100 // debug statements here
29102 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
29104 export function ParseOrSemanticError_clone_ptr(arg: number): number {
29105 if(!isWasmInitialized) {
29106 throw new Error("initializeWasm() must be awaited first!");
29108 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
29109 return nativeResponseValue;
29111 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
29113 export function ParseOrSemanticError_clone(orig: number): number {
29114 if(!isWasmInitialized) {
29115 throw new Error("initializeWasm() must be awaited first!");
29117 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
29118 return nativeResponseValue;
29120 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
29122 export function ParseOrSemanticError_parse_error(a: number): number {
29123 if(!isWasmInitialized) {
29124 throw new Error("initializeWasm() must be awaited first!");
29126 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
29127 return nativeResponseValue;
29129 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
29131 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
29132 if(!isWasmInitialized) {
29133 throw new Error("initializeWasm() must be awaited first!");
29135 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
29136 return nativeResponseValue;
29138 // void Invoice_free(struct LDKInvoice this_obj);
29140 export function Invoice_free(this_obj: number): void {
29141 if(!isWasmInitialized) {
29142 throw new Error("initializeWasm() must be awaited first!");
29144 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
29145 // debug statements here
29147 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
29149 export function Invoice_eq(a: number, b: number): boolean {
29150 if(!isWasmInitialized) {
29151 throw new Error("initializeWasm() must be awaited first!");
29153 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
29154 return nativeResponseValue;
29156 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
29158 export function Invoice_clone_ptr(arg: number): number {
29159 if(!isWasmInitialized) {
29160 throw new Error("initializeWasm() must be awaited first!");
29162 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
29163 return nativeResponseValue;
29165 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
29167 export function Invoice_clone(orig: number): number {
29168 if(!isWasmInitialized) {
29169 throw new Error("initializeWasm() must be awaited first!");
29171 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
29172 return nativeResponseValue;
29174 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
29176 export function SignedRawInvoice_free(this_obj: number): void {
29177 if(!isWasmInitialized) {
29178 throw new Error("initializeWasm() must be awaited first!");
29180 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
29181 // debug statements here
29183 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
29185 export function SignedRawInvoice_eq(a: number, b: number): boolean {
29186 if(!isWasmInitialized) {
29187 throw new Error("initializeWasm() must be awaited first!");
29189 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
29190 return nativeResponseValue;
29192 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
29194 export function SignedRawInvoice_clone_ptr(arg: number): number {
29195 if(!isWasmInitialized) {
29196 throw new Error("initializeWasm() must be awaited first!");
29198 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
29199 return nativeResponseValue;
29201 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
29203 export function SignedRawInvoice_clone(orig: number): number {
29204 if(!isWasmInitialized) {
29205 throw new Error("initializeWasm() must be awaited first!");
29207 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
29208 return nativeResponseValue;
29210 // void RawInvoice_free(struct LDKRawInvoice this_obj);
29212 export function RawInvoice_free(this_obj: number): void {
29213 if(!isWasmInitialized) {
29214 throw new Error("initializeWasm() must be awaited first!");
29216 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
29217 // debug statements here
29219 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
29221 export function RawInvoice_get_data(this_ptr: number): number {
29222 if(!isWasmInitialized) {
29223 throw new Error("initializeWasm() must be awaited first!");
29225 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
29226 return nativeResponseValue;
29228 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
29230 export function RawInvoice_set_data(this_ptr: number, val: number): void {
29231 if(!isWasmInitialized) {
29232 throw new Error("initializeWasm() must be awaited first!");
29234 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
29235 // debug statements here
29237 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
29239 export function RawInvoice_eq(a: number, b: number): boolean {
29240 if(!isWasmInitialized) {
29241 throw new Error("initializeWasm() must be awaited first!");
29243 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
29244 return nativeResponseValue;
29246 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
29248 export function RawInvoice_clone_ptr(arg: number): number {
29249 if(!isWasmInitialized) {
29250 throw new Error("initializeWasm() must be awaited first!");
29252 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
29253 return nativeResponseValue;
29255 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
29257 export function RawInvoice_clone(orig: number): number {
29258 if(!isWasmInitialized) {
29259 throw new Error("initializeWasm() must be awaited first!");
29261 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
29262 return nativeResponseValue;
29264 // void RawDataPart_free(struct LDKRawDataPart this_obj);
29266 export function RawDataPart_free(this_obj: number): void {
29267 if(!isWasmInitialized) {
29268 throw new Error("initializeWasm() must be awaited first!");
29270 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
29271 // debug statements here
29273 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
29275 export function RawDataPart_get_timestamp(this_ptr: number): number {
29276 if(!isWasmInitialized) {
29277 throw new Error("initializeWasm() must be awaited first!");
29279 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
29280 return nativeResponseValue;
29282 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
29284 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
29285 if(!isWasmInitialized) {
29286 throw new Error("initializeWasm() must be awaited first!");
29288 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
29289 // debug statements here
29291 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
29293 export function RawDataPart_eq(a: number, b: number): boolean {
29294 if(!isWasmInitialized) {
29295 throw new Error("initializeWasm() must be awaited first!");
29297 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
29298 return nativeResponseValue;
29300 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
29302 export function RawDataPart_clone_ptr(arg: number): number {
29303 if(!isWasmInitialized) {
29304 throw new Error("initializeWasm() must be awaited first!");
29306 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
29307 return nativeResponseValue;
29309 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
29311 export function RawDataPart_clone(orig: number): number {
29312 if(!isWasmInitialized) {
29313 throw new Error("initializeWasm() must be awaited first!");
29315 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
29316 return nativeResponseValue;
29318 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
29320 export function PositiveTimestamp_free(this_obj: number): void {
29321 if(!isWasmInitialized) {
29322 throw new Error("initializeWasm() must be awaited first!");
29324 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
29325 // debug statements here
29327 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
29329 export function PositiveTimestamp_eq(a: number, b: number): boolean {
29330 if(!isWasmInitialized) {
29331 throw new Error("initializeWasm() must be awaited first!");
29333 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
29334 return nativeResponseValue;
29336 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
29338 export function PositiveTimestamp_clone_ptr(arg: number): number {
29339 if(!isWasmInitialized) {
29340 throw new Error("initializeWasm() must be awaited first!");
29342 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
29343 return nativeResponseValue;
29345 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
29347 export function PositiveTimestamp_clone(orig: number): number {
29348 if(!isWasmInitialized) {
29349 throw new Error("initializeWasm() must be awaited first!");
29351 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
29352 return nativeResponseValue;
29354 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
29356 export function SiPrefix_clone(orig: number): SiPrefix {
29357 if(!isWasmInitialized) {
29358 throw new Error("initializeWasm() must be awaited first!");
29360 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
29361 return nativeResponseValue;
29363 // enum LDKSiPrefix SiPrefix_milli(void);
29365 export function SiPrefix_milli(): SiPrefix {
29366 if(!isWasmInitialized) {
29367 throw new Error("initializeWasm() must be awaited first!");
29369 const nativeResponseValue = wasm.TS_SiPrefix_milli();
29370 return nativeResponseValue;
29372 // enum LDKSiPrefix SiPrefix_micro(void);
29374 export function SiPrefix_micro(): SiPrefix {
29375 if(!isWasmInitialized) {
29376 throw new Error("initializeWasm() must be awaited first!");
29378 const nativeResponseValue = wasm.TS_SiPrefix_micro();
29379 return nativeResponseValue;
29381 // enum LDKSiPrefix SiPrefix_nano(void);
29383 export function SiPrefix_nano(): SiPrefix {
29384 if(!isWasmInitialized) {
29385 throw new Error("initializeWasm() must be awaited first!");
29387 const nativeResponseValue = wasm.TS_SiPrefix_nano();
29388 return nativeResponseValue;
29390 // enum LDKSiPrefix SiPrefix_pico(void);
29392 export function SiPrefix_pico(): SiPrefix {
29393 if(!isWasmInitialized) {
29394 throw new Error("initializeWasm() must be awaited first!");
29396 const nativeResponseValue = wasm.TS_SiPrefix_pico();
29397 return nativeResponseValue;
29399 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
29401 export function SiPrefix_eq(a: number, b: number): boolean {
29402 if(!isWasmInitialized) {
29403 throw new Error("initializeWasm() must be awaited first!");
29405 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
29406 return nativeResponseValue;
29408 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
29410 export function SiPrefix_multiplier(this_arg: number): bigint {
29411 if(!isWasmInitialized) {
29412 throw new Error("initializeWasm() must be awaited first!");
29414 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
29415 return nativeResponseValue;
29417 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
29419 export function Currency_clone(orig: number): Currency {
29420 if(!isWasmInitialized) {
29421 throw new Error("initializeWasm() must be awaited first!");
29423 const nativeResponseValue = wasm.TS_Currency_clone(orig);
29424 return nativeResponseValue;
29426 // enum LDKCurrency Currency_bitcoin(void);
29428 export function Currency_bitcoin(): Currency {
29429 if(!isWasmInitialized) {
29430 throw new Error("initializeWasm() must be awaited first!");
29432 const nativeResponseValue = wasm.TS_Currency_bitcoin();
29433 return nativeResponseValue;
29435 // enum LDKCurrency Currency_bitcoin_testnet(void);
29437 export function Currency_bitcoin_testnet(): Currency {
29438 if(!isWasmInitialized) {
29439 throw new Error("initializeWasm() must be awaited first!");
29441 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
29442 return nativeResponseValue;
29444 // enum LDKCurrency Currency_regtest(void);
29446 export function Currency_regtest(): Currency {
29447 if(!isWasmInitialized) {
29448 throw new Error("initializeWasm() must be awaited first!");
29450 const nativeResponseValue = wasm.TS_Currency_regtest();
29451 return nativeResponseValue;
29453 // enum LDKCurrency Currency_simnet(void);
29455 export function Currency_simnet(): Currency {
29456 if(!isWasmInitialized) {
29457 throw new Error("initializeWasm() must be awaited first!");
29459 const nativeResponseValue = wasm.TS_Currency_simnet();
29460 return nativeResponseValue;
29462 // enum LDKCurrency Currency_signet(void);
29464 export function Currency_signet(): Currency {
29465 if(!isWasmInitialized) {
29466 throw new Error("initializeWasm() must be awaited first!");
29468 const nativeResponseValue = wasm.TS_Currency_signet();
29469 return nativeResponseValue;
29471 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
29473 export function Currency_hash(o: number): bigint {
29474 if(!isWasmInitialized) {
29475 throw new Error("initializeWasm() must be awaited first!");
29477 const nativeResponseValue = wasm.TS_Currency_hash(o);
29478 return nativeResponseValue;
29480 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
29482 export function Currency_eq(a: number, b: number): boolean {
29483 if(!isWasmInitialized) {
29484 throw new Error("initializeWasm() must be awaited first!");
29486 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
29487 return nativeResponseValue;
29489 // void Sha256_free(struct LDKSha256 this_obj);
29491 export function Sha256_free(this_obj: number): void {
29492 if(!isWasmInitialized) {
29493 throw new Error("initializeWasm() must be awaited first!");
29495 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
29496 // debug statements here
29498 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
29500 export function Sha256_clone_ptr(arg: number): number {
29501 if(!isWasmInitialized) {
29502 throw new Error("initializeWasm() must be awaited first!");
29504 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
29505 return nativeResponseValue;
29507 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
29509 export function Sha256_clone(orig: number): number {
29510 if(!isWasmInitialized) {
29511 throw new Error("initializeWasm() must be awaited first!");
29513 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
29514 return nativeResponseValue;
29516 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
29518 export function Sha256_hash(o: number): bigint {
29519 if(!isWasmInitialized) {
29520 throw new Error("initializeWasm() must be awaited first!");
29522 const nativeResponseValue = wasm.TS_Sha256_hash(o);
29523 return nativeResponseValue;
29525 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
29527 export function Sha256_eq(a: number, b: number): boolean {
29528 if(!isWasmInitialized) {
29529 throw new Error("initializeWasm() must be awaited first!");
29531 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
29532 return nativeResponseValue;
29534 // void Description_free(struct LDKDescription this_obj);
29536 export function Description_free(this_obj: number): void {
29537 if(!isWasmInitialized) {
29538 throw new Error("initializeWasm() must be awaited first!");
29540 const nativeResponseValue = wasm.TS_Description_free(this_obj);
29541 // debug statements here
29543 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
29545 export function Description_clone_ptr(arg: number): number {
29546 if(!isWasmInitialized) {
29547 throw new Error("initializeWasm() must be awaited first!");
29549 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
29550 return nativeResponseValue;
29552 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
29554 export function Description_clone(orig: number): number {
29555 if(!isWasmInitialized) {
29556 throw new Error("initializeWasm() must be awaited first!");
29558 const nativeResponseValue = wasm.TS_Description_clone(orig);
29559 return nativeResponseValue;
29561 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
29563 export function Description_hash(o: number): bigint {
29564 if(!isWasmInitialized) {
29565 throw new Error("initializeWasm() must be awaited first!");
29567 const nativeResponseValue = wasm.TS_Description_hash(o);
29568 return nativeResponseValue;
29570 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
29572 export function Description_eq(a: number, b: number): boolean {
29573 if(!isWasmInitialized) {
29574 throw new Error("initializeWasm() must be awaited first!");
29576 const nativeResponseValue = wasm.TS_Description_eq(a, b);
29577 return nativeResponseValue;
29579 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
29581 export function PayeePubKey_free(this_obj: number): void {
29582 if(!isWasmInitialized) {
29583 throw new Error("initializeWasm() must be awaited first!");
29585 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
29586 // debug statements here
29588 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
29590 export function PayeePubKey_get_a(this_ptr: number): number {
29591 if(!isWasmInitialized) {
29592 throw new Error("initializeWasm() must be awaited first!");
29594 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
29595 return nativeResponseValue;
29597 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29599 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
29600 if(!isWasmInitialized) {
29601 throw new Error("initializeWasm() must be awaited first!");
29603 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
29604 // debug statements here
29606 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
29608 export function PayeePubKey_new(a_arg: number): number {
29609 if(!isWasmInitialized) {
29610 throw new Error("initializeWasm() must be awaited first!");
29612 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
29613 return nativeResponseValue;
29615 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
29617 export function PayeePubKey_clone_ptr(arg: number): number {
29618 if(!isWasmInitialized) {
29619 throw new Error("initializeWasm() must be awaited first!");
29621 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
29622 return nativeResponseValue;
29624 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
29626 export function PayeePubKey_clone(orig: number): number {
29627 if(!isWasmInitialized) {
29628 throw new Error("initializeWasm() must be awaited first!");
29630 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
29631 return nativeResponseValue;
29633 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
29635 export function PayeePubKey_hash(o: number): bigint {
29636 if(!isWasmInitialized) {
29637 throw new Error("initializeWasm() must be awaited first!");
29639 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
29640 return nativeResponseValue;
29642 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
29644 export function PayeePubKey_eq(a: number, b: number): boolean {
29645 if(!isWasmInitialized) {
29646 throw new Error("initializeWasm() must be awaited first!");
29648 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
29649 return nativeResponseValue;
29651 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
29653 export function ExpiryTime_free(this_obj: number): void {
29654 if(!isWasmInitialized) {
29655 throw new Error("initializeWasm() must be awaited first!");
29657 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
29658 // debug statements here
29660 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
29662 export function ExpiryTime_clone_ptr(arg: number): number {
29663 if(!isWasmInitialized) {
29664 throw new Error("initializeWasm() must be awaited first!");
29666 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
29667 return nativeResponseValue;
29669 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
29671 export function ExpiryTime_clone(orig: number): number {
29672 if(!isWasmInitialized) {
29673 throw new Error("initializeWasm() must be awaited first!");
29675 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
29676 return nativeResponseValue;
29678 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
29680 export function ExpiryTime_hash(o: number): bigint {
29681 if(!isWasmInitialized) {
29682 throw new Error("initializeWasm() must be awaited first!");
29684 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
29685 return nativeResponseValue;
29687 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
29689 export function ExpiryTime_eq(a: number, b: number): boolean {
29690 if(!isWasmInitialized) {
29691 throw new Error("initializeWasm() must be awaited first!");
29693 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
29694 return nativeResponseValue;
29696 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
29698 export function MinFinalCltvExpiry_free(this_obj: number): void {
29699 if(!isWasmInitialized) {
29700 throw new Error("initializeWasm() must be awaited first!");
29702 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
29703 // debug statements here
29705 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
29707 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
29708 if(!isWasmInitialized) {
29709 throw new Error("initializeWasm() must be awaited first!");
29711 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
29712 return nativeResponseValue;
29714 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
29716 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
29717 if(!isWasmInitialized) {
29718 throw new Error("initializeWasm() must be awaited first!");
29720 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
29721 // debug statements here
29723 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
29725 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
29726 if(!isWasmInitialized) {
29727 throw new Error("initializeWasm() must be awaited first!");
29729 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
29730 return nativeResponseValue;
29732 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
29734 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
29735 if(!isWasmInitialized) {
29736 throw new Error("initializeWasm() must be awaited first!");
29738 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
29739 return nativeResponseValue;
29741 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
29743 export function MinFinalCltvExpiry_clone(orig: number): number {
29744 if(!isWasmInitialized) {
29745 throw new Error("initializeWasm() must be awaited first!");
29747 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
29748 return nativeResponseValue;
29750 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
29752 export function MinFinalCltvExpiry_hash(o: number): bigint {
29753 if(!isWasmInitialized) {
29754 throw new Error("initializeWasm() must be awaited first!");
29756 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
29757 return nativeResponseValue;
29759 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
29761 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
29762 if(!isWasmInitialized) {
29763 throw new Error("initializeWasm() must be awaited first!");
29765 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
29766 return nativeResponseValue;
29768 // void Fallback_free(struct LDKFallback this_ptr);
29770 export function Fallback_free(this_ptr: number): void {
29771 if(!isWasmInitialized) {
29772 throw new Error("initializeWasm() must be awaited first!");
29774 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
29775 // debug statements here
29777 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
29779 export function Fallback_clone_ptr(arg: number): number {
29780 if(!isWasmInitialized) {
29781 throw new Error("initializeWasm() must be awaited first!");
29783 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
29784 return nativeResponseValue;
29786 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
29788 export function Fallback_clone(orig: number): number {
29789 if(!isWasmInitialized) {
29790 throw new Error("initializeWasm() must be awaited first!");
29792 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
29793 return nativeResponseValue;
29795 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
29797 export function Fallback_seg_wit_program(version: number, program: number): number {
29798 if(!isWasmInitialized) {
29799 throw new Error("initializeWasm() must be awaited first!");
29801 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
29802 return nativeResponseValue;
29804 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
29806 export function Fallback_pub_key_hash(a: number): number {
29807 if(!isWasmInitialized) {
29808 throw new Error("initializeWasm() must be awaited first!");
29810 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
29811 return nativeResponseValue;
29813 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
29815 export function Fallback_script_hash(a: number): number {
29816 if(!isWasmInitialized) {
29817 throw new Error("initializeWasm() must be awaited first!");
29819 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
29820 return nativeResponseValue;
29822 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
29824 export function Fallback_hash(o: number): bigint {
29825 if(!isWasmInitialized) {
29826 throw new Error("initializeWasm() must be awaited first!");
29828 const nativeResponseValue = wasm.TS_Fallback_hash(o);
29829 return nativeResponseValue;
29831 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
29833 export function Fallback_eq(a: number, b: number): boolean {
29834 if(!isWasmInitialized) {
29835 throw new Error("initializeWasm() must be awaited first!");
29837 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
29838 return nativeResponseValue;
29840 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
29842 export function InvoiceSignature_free(this_obj: number): void {
29843 if(!isWasmInitialized) {
29844 throw new Error("initializeWasm() must be awaited first!");
29846 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
29847 // debug statements here
29849 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
29851 export function InvoiceSignature_clone_ptr(arg: number): number {
29852 if(!isWasmInitialized) {
29853 throw new Error("initializeWasm() must be awaited first!");
29855 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
29856 return nativeResponseValue;
29858 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
29860 export function InvoiceSignature_clone(orig: number): number {
29861 if(!isWasmInitialized) {
29862 throw new Error("initializeWasm() must be awaited first!");
29864 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
29865 return nativeResponseValue;
29867 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
29869 export function InvoiceSignature_eq(a: number, b: number): boolean {
29870 if(!isWasmInitialized) {
29871 throw new Error("initializeWasm() must be awaited first!");
29873 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
29874 return nativeResponseValue;
29876 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
29878 export function PrivateRoute_free(this_obj: number): void {
29879 if(!isWasmInitialized) {
29880 throw new Error("initializeWasm() must be awaited first!");
29882 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
29883 // debug statements here
29885 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
29887 export function PrivateRoute_clone_ptr(arg: number): number {
29888 if(!isWasmInitialized) {
29889 throw new Error("initializeWasm() must be awaited first!");
29891 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
29892 return nativeResponseValue;
29894 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
29896 export function PrivateRoute_clone(orig: number): number {
29897 if(!isWasmInitialized) {
29898 throw new Error("initializeWasm() must be awaited first!");
29900 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
29901 return nativeResponseValue;
29903 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
29905 export function PrivateRoute_hash(o: number): bigint {
29906 if(!isWasmInitialized) {
29907 throw new Error("initializeWasm() must be awaited first!");
29909 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
29910 return nativeResponseValue;
29912 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
29914 export function PrivateRoute_eq(a: number, b: number): boolean {
29915 if(!isWasmInitialized) {
29916 throw new Error("initializeWasm() must be awaited first!");
29918 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
29919 return nativeResponseValue;
29921 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
29923 export function SignedRawInvoice_into_parts(this_arg: number): number {
29924 if(!isWasmInitialized) {
29925 throw new Error("initializeWasm() must be awaited first!");
29927 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
29928 return nativeResponseValue;
29930 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29932 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
29933 if(!isWasmInitialized) {
29934 throw new Error("initializeWasm() must be awaited first!");
29936 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
29937 return nativeResponseValue;
29939 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
29941 export function SignedRawInvoice_hash(this_arg: number): number {
29942 if(!isWasmInitialized) {
29943 throw new Error("initializeWasm() must be awaited first!");
29945 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
29946 return nativeResponseValue;
29948 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29950 export function SignedRawInvoice_signature(this_arg: number): number {
29951 if(!isWasmInitialized) {
29952 throw new Error("initializeWasm() must be awaited first!");
29954 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
29955 return nativeResponseValue;
29957 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29959 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
29960 if(!isWasmInitialized) {
29961 throw new Error("initializeWasm() must be awaited first!");
29963 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
29964 return nativeResponseValue;
29966 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
29968 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
29969 if(!isWasmInitialized) {
29970 throw new Error("initializeWasm() must be awaited first!");
29972 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
29973 return nativeResponseValue;
29975 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29977 export function RawInvoice_hash(this_arg: number): number {
29978 if(!isWasmInitialized) {
29979 throw new Error("initializeWasm() must be awaited first!");
29981 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
29982 return nativeResponseValue;
29984 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29986 export function RawInvoice_payment_hash(this_arg: number): number {
29987 if(!isWasmInitialized) {
29988 throw new Error("initializeWasm() must be awaited first!");
29990 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
29991 return nativeResponseValue;
29993 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
29995 export function RawInvoice_description(this_arg: number): number {
29996 if(!isWasmInitialized) {
29997 throw new Error("initializeWasm() must be awaited first!");
29999 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
30000 return nativeResponseValue;
30002 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30004 export function RawInvoice_payee_pub_key(this_arg: number): number {
30005 if(!isWasmInitialized) {
30006 throw new Error("initializeWasm() must be awaited first!");
30008 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
30009 return nativeResponseValue;
30011 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30013 export function RawInvoice_description_hash(this_arg: number): number {
30014 if(!isWasmInitialized) {
30015 throw new Error("initializeWasm() must be awaited first!");
30017 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
30018 return nativeResponseValue;
30020 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30022 export function RawInvoice_expiry_time(this_arg: number): number {
30023 if(!isWasmInitialized) {
30024 throw new Error("initializeWasm() must be awaited first!");
30026 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
30027 return nativeResponseValue;
30029 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30031 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
30032 if(!isWasmInitialized) {
30033 throw new Error("initializeWasm() must be awaited first!");
30035 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
30036 return nativeResponseValue;
30038 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30040 export function RawInvoice_payment_secret(this_arg: number): number {
30041 if(!isWasmInitialized) {
30042 throw new Error("initializeWasm() must be awaited first!");
30044 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
30045 return nativeResponseValue;
30047 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30049 export function RawInvoice_features(this_arg: number): number {
30050 if(!isWasmInitialized) {
30051 throw new Error("initializeWasm() must be awaited first!");
30053 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
30054 return nativeResponseValue;
30056 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30058 export function RawInvoice_private_routes(this_arg: number): number {
30059 if(!isWasmInitialized) {
30060 throw new Error("initializeWasm() must be awaited first!");
30062 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
30063 return nativeResponseValue;
30065 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30067 export function RawInvoice_amount_pico_btc(this_arg: number): number {
30068 if(!isWasmInitialized) {
30069 throw new Error("initializeWasm() must be awaited first!");
30071 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
30072 return nativeResponseValue;
30074 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
30076 export function RawInvoice_currency(this_arg: number): Currency {
30077 if(!isWasmInitialized) {
30078 throw new Error("initializeWasm() must be awaited first!");
30080 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
30081 return nativeResponseValue;
30083 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
30085 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
30086 if(!isWasmInitialized) {
30087 throw new Error("initializeWasm() must be awaited first!");
30089 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
30090 return nativeResponseValue;
30092 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
30094 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
30095 if(!isWasmInitialized) {
30096 throw new Error("initializeWasm() must be awaited first!");
30098 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
30099 return nativeResponseValue;
30101 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
30103 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
30104 if(!isWasmInitialized) {
30105 throw new Error("initializeWasm() must be awaited first!");
30107 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
30108 return nativeResponseValue;
30110 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
30112 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
30113 if(!isWasmInitialized) {
30114 throw new Error("initializeWasm() must be awaited first!");
30116 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
30117 return nativeResponseValue;
30119 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
30121 export function Invoice_into_signed_raw(this_arg: number): number {
30122 if(!isWasmInitialized) {
30123 throw new Error("initializeWasm() must be awaited first!");
30125 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
30126 return nativeResponseValue;
30128 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
30130 export function Invoice_check_signature(this_arg: number): number {
30131 if(!isWasmInitialized) {
30132 throw new Error("initializeWasm() must be awaited first!");
30134 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
30135 return nativeResponseValue;
30137 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
30139 export function Invoice_from_signed(signed_invoice: number): number {
30140 if(!isWasmInitialized) {
30141 throw new Error("initializeWasm() must be awaited first!");
30143 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
30144 return nativeResponseValue;
30146 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
30148 export function Invoice_duration_since_epoch(this_arg: number): bigint {
30149 if(!isWasmInitialized) {
30150 throw new Error("initializeWasm() must be awaited first!");
30152 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
30153 return nativeResponseValue;
30155 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
30157 export function Invoice_payment_hash(this_arg: number): number {
30158 if(!isWasmInitialized) {
30159 throw new Error("initializeWasm() must be awaited first!");
30161 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
30162 return nativeResponseValue;
30164 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
30166 export function Invoice_payee_pub_key(this_arg: number): number {
30167 if(!isWasmInitialized) {
30168 throw new Error("initializeWasm() must be awaited first!");
30170 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
30171 return nativeResponseValue;
30173 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
30175 export function Invoice_payment_secret(this_arg: number): number {
30176 if(!isWasmInitialized) {
30177 throw new Error("initializeWasm() must be awaited first!");
30179 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
30180 return nativeResponseValue;
30182 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
30184 export function Invoice_features(this_arg: number): number {
30185 if(!isWasmInitialized) {
30186 throw new Error("initializeWasm() must be awaited first!");
30188 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
30189 return nativeResponseValue;
30191 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
30193 export function Invoice_recover_payee_pub_key(this_arg: number): number {
30194 if(!isWasmInitialized) {
30195 throw new Error("initializeWasm() must be awaited first!");
30197 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
30198 return nativeResponseValue;
30200 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
30202 export function Invoice_expiry_time(this_arg: number): bigint {
30203 if(!isWasmInitialized) {
30204 throw new Error("initializeWasm() must be awaited first!");
30206 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
30207 return nativeResponseValue;
30209 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
30211 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
30212 if(!isWasmInitialized) {
30213 throw new Error("initializeWasm() must be awaited first!");
30215 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
30216 return nativeResponseValue;
30218 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
30220 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
30221 if(!isWasmInitialized) {
30222 throw new Error("initializeWasm() must be awaited first!");
30224 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
30225 return nativeResponseValue;
30227 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
30229 export function Invoice_private_routes(this_arg: number): number {
30230 if(!isWasmInitialized) {
30231 throw new Error("initializeWasm() must be awaited first!");
30233 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
30234 return nativeResponseValue;
30236 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
30238 export function Invoice_route_hints(this_arg: number): number {
30239 if(!isWasmInitialized) {
30240 throw new Error("initializeWasm() must be awaited first!");
30242 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
30243 return nativeResponseValue;
30245 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
30247 export function Invoice_currency(this_arg: number): Currency {
30248 if(!isWasmInitialized) {
30249 throw new Error("initializeWasm() must be awaited first!");
30251 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
30252 return nativeResponseValue;
30254 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
30256 export function Invoice_amount_milli_satoshis(this_arg: number): number {
30257 if(!isWasmInitialized) {
30258 throw new Error("initializeWasm() must be awaited first!");
30260 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
30261 return nativeResponseValue;
30263 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
30265 export function Description_new(description: number): number {
30266 if(!isWasmInitialized) {
30267 throw new Error("initializeWasm() must be awaited first!");
30269 const nativeResponseValue = wasm.TS_Description_new(description);
30270 return nativeResponseValue;
30272 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
30274 export function Description_into_inner(this_arg: number): number {
30275 if(!isWasmInitialized) {
30276 throw new Error("initializeWasm() must be awaited first!");
30278 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
30279 return nativeResponseValue;
30281 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
30283 export function ExpiryTime_from_seconds(seconds: bigint): number {
30284 if(!isWasmInitialized) {
30285 throw new Error("initializeWasm() must be awaited first!");
30287 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
30288 return nativeResponseValue;
30290 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
30292 export function ExpiryTime_from_duration(duration: bigint): number {
30293 if(!isWasmInitialized) {
30294 throw new Error("initializeWasm() must be awaited first!");
30296 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
30297 return nativeResponseValue;
30299 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
30301 export function ExpiryTime_as_seconds(this_arg: number): bigint {
30302 if(!isWasmInitialized) {
30303 throw new Error("initializeWasm() must be awaited first!");
30305 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
30306 return nativeResponseValue;
30308 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
30310 export function ExpiryTime_as_duration(this_arg: number): bigint {
30311 if(!isWasmInitialized) {
30312 throw new Error("initializeWasm() must be awaited first!");
30314 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
30315 return nativeResponseValue;
30317 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
30319 export function PrivateRoute_new(hops: number): number {
30320 if(!isWasmInitialized) {
30321 throw new Error("initializeWasm() must be awaited first!");
30323 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
30324 return nativeResponseValue;
30326 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
30328 export function PrivateRoute_into_inner(this_arg: number): number {
30329 if(!isWasmInitialized) {
30330 throw new Error("initializeWasm() must be awaited first!");
30332 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
30333 return nativeResponseValue;
30335 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
30337 export function CreationError_clone(orig: number): CreationError {
30338 if(!isWasmInitialized) {
30339 throw new Error("initializeWasm() must be awaited first!");
30341 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
30342 return nativeResponseValue;
30344 // enum LDKCreationError CreationError_description_too_long(void);
30346 export function CreationError_description_too_long(): CreationError {
30347 if(!isWasmInitialized) {
30348 throw new Error("initializeWasm() must be awaited first!");
30350 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
30351 return nativeResponseValue;
30353 // enum LDKCreationError CreationError_route_too_long(void);
30355 export function CreationError_route_too_long(): CreationError {
30356 if(!isWasmInitialized) {
30357 throw new Error("initializeWasm() must be awaited first!");
30359 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
30360 return nativeResponseValue;
30362 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
30364 export function CreationError_timestamp_out_of_bounds(): CreationError {
30365 if(!isWasmInitialized) {
30366 throw new Error("initializeWasm() must be awaited first!");
30368 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
30369 return nativeResponseValue;
30371 // enum LDKCreationError CreationError_invalid_amount(void);
30373 export function CreationError_invalid_amount(): CreationError {
30374 if(!isWasmInitialized) {
30375 throw new Error("initializeWasm() must be awaited first!");
30377 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
30378 return nativeResponseValue;
30380 // enum LDKCreationError CreationError_missing_route_hints(void);
30382 export function CreationError_missing_route_hints(): CreationError {
30383 if(!isWasmInitialized) {
30384 throw new Error("initializeWasm() must be awaited first!");
30386 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
30387 return nativeResponseValue;
30389 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
30391 export function CreationError_eq(a: number, b: number): boolean {
30392 if(!isWasmInitialized) {
30393 throw new Error("initializeWasm() must be awaited first!");
30395 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
30396 return nativeResponseValue;
30398 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
30400 export function CreationError_to_str(o: number): number {
30401 if(!isWasmInitialized) {
30402 throw new Error("initializeWasm() must be awaited first!");
30404 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
30405 return nativeResponseValue;
30407 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
30409 export function SemanticError_clone(orig: number): SemanticError {
30410 if(!isWasmInitialized) {
30411 throw new Error("initializeWasm() must be awaited first!");
30413 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
30414 return nativeResponseValue;
30416 // enum LDKSemanticError SemanticError_no_payment_hash(void);
30418 export function SemanticError_no_payment_hash(): SemanticError {
30419 if(!isWasmInitialized) {
30420 throw new Error("initializeWasm() must be awaited first!");
30422 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
30423 return nativeResponseValue;
30425 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
30427 export function SemanticError_multiple_payment_hashes(): SemanticError {
30428 if(!isWasmInitialized) {
30429 throw new Error("initializeWasm() must be awaited first!");
30431 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
30432 return nativeResponseValue;
30434 // enum LDKSemanticError SemanticError_no_description(void);
30436 export function SemanticError_no_description(): SemanticError {
30437 if(!isWasmInitialized) {
30438 throw new Error("initializeWasm() must be awaited first!");
30440 const nativeResponseValue = wasm.TS_SemanticError_no_description();
30441 return nativeResponseValue;
30443 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
30445 export function SemanticError_multiple_descriptions(): SemanticError {
30446 if(!isWasmInitialized) {
30447 throw new Error("initializeWasm() must be awaited first!");
30449 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
30450 return nativeResponseValue;
30452 // enum LDKSemanticError SemanticError_no_payment_secret(void);
30454 export function SemanticError_no_payment_secret(): SemanticError {
30455 if(!isWasmInitialized) {
30456 throw new Error("initializeWasm() must be awaited first!");
30458 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
30459 return nativeResponseValue;
30461 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
30463 export function SemanticError_multiple_payment_secrets(): SemanticError {
30464 if(!isWasmInitialized) {
30465 throw new Error("initializeWasm() must be awaited first!");
30467 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
30468 return nativeResponseValue;
30470 // enum LDKSemanticError SemanticError_invalid_features(void);
30472 export function SemanticError_invalid_features(): SemanticError {
30473 if(!isWasmInitialized) {
30474 throw new Error("initializeWasm() must be awaited first!");
30476 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
30477 return nativeResponseValue;
30479 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
30481 export function SemanticError_invalid_recovery_id(): SemanticError {
30482 if(!isWasmInitialized) {
30483 throw new Error("initializeWasm() must be awaited first!");
30485 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
30486 return nativeResponseValue;
30488 // enum LDKSemanticError SemanticError_invalid_signature(void);
30490 export function SemanticError_invalid_signature(): SemanticError {
30491 if(!isWasmInitialized) {
30492 throw new Error("initializeWasm() must be awaited first!");
30494 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
30495 return nativeResponseValue;
30497 // enum LDKSemanticError SemanticError_imprecise_amount(void);
30499 export function SemanticError_imprecise_amount(): SemanticError {
30500 if(!isWasmInitialized) {
30501 throw new Error("initializeWasm() must be awaited first!");
30503 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
30504 return nativeResponseValue;
30506 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
30508 export function SemanticError_eq(a: number, b: number): boolean {
30509 if(!isWasmInitialized) {
30510 throw new Error("initializeWasm() must be awaited first!");
30512 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
30513 return nativeResponseValue;
30515 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
30517 export function SemanticError_to_str(o: number): number {
30518 if(!isWasmInitialized) {
30519 throw new Error("initializeWasm() must be awaited first!");
30521 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
30522 return nativeResponseValue;
30524 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
30526 export function SignOrCreationError_free(this_ptr: number): void {
30527 if(!isWasmInitialized) {
30528 throw new Error("initializeWasm() must be awaited first!");
30530 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
30531 // debug statements here
30533 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
30535 export function SignOrCreationError_clone_ptr(arg: number): number {
30536 if(!isWasmInitialized) {
30537 throw new Error("initializeWasm() must be awaited first!");
30539 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
30540 return nativeResponseValue;
30542 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
30544 export function SignOrCreationError_clone(orig: number): number {
30545 if(!isWasmInitialized) {
30546 throw new Error("initializeWasm() must be awaited first!");
30548 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
30549 return nativeResponseValue;
30551 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
30553 export function SignOrCreationError_sign_error(): number {
30554 if(!isWasmInitialized) {
30555 throw new Error("initializeWasm() must be awaited first!");
30557 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
30558 return nativeResponseValue;
30560 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
30562 export function SignOrCreationError_creation_error(a: CreationError): number {
30563 if(!isWasmInitialized) {
30564 throw new Error("initializeWasm() must be awaited first!");
30566 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
30567 return nativeResponseValue;
30569 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
30571 export function SignOrCreationError_eq(a: number, b: number): boolean {
30572 if(!isWasmInitialized) {
30573 throw new Error("initializeWasm() must be awaited first!");
30575 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
30576 return nativeResponseValue;
30578 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
30580 export function SignOrCreationError_to_str(o: number): number {
30581 if(!isWasmInitialized) {
30582 throw new Error("initializeWasm() must be awaited first!");
30584 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
30585 return nativeResponseValue;
30587 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
30589 export function InvoicePayer_free(this_obj: number): void {
30590 if(!isWasmInitialized) {
30591 throw new Error("initializeWasm() must be awaited first!");
30593 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
30594 // debug statements here
30596 // void Payer_free(struct LDKPayer this_ptr);
30598 export function Payer_free(this_ptr: number): void {
30599 if(!isWasmInitialized) {
30600 throw new Error("initializeWasm() must be awaited first!");
30602 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
30603 // debug statements here
30605 // void Router_free(struct LDKRouter this_ptr);
30607 export function Router_free(this_ptr: number): void {
30608 if(!isWasmInitialized) {
30609 throw new Error("initializeWasm() must be awaited first!");
30611 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
30612 // debug statements here
30614 // void RetryAttempts_free(struct LDKRetryAttempts this_obj);
30616 export function RetryAttempts_free(this_obj: number): void {
30617 if(!isWasmInitialized) {
30618 throw new Error("initializeWasm() must be awaited first!");
30620 const nativeResponseValue = wasm.TS_RetryAttempts_free(this_obj);
30621 // debug statements here
30623 // uintptr_t RetryAttempts_get_a(const struct LDKRetryAttempts *NONNULL_PTR this_ptr);
30625 export function RetryAttempts_get_a(this_ptr: number): number {
30626 if(!isWasmInitialized) {
30627 throw new Error("initializeWasm() must be awaited first!");
30629 const nativeResponseValue = wasm.TS_RetryAttempts_get_a(this_ptr);
30630 return nativeResponseValue;
30632 // void RetryAttempts_set_a(struct LDKRetryAttempts *NONNULL_PTR this_ptr, uintptr_t val);
30634 export function RetryAttempts_set_a(this_ptr: number, val: number): void {
30635 if(!isWasmInitialized) {
30636 throw new Error("initializeWasm() must be awaited first!");
30638 const nativeResponseValue = wasm.TS_RetryAttempts_set_a(this_ptr, val);
30639 // debug statements here
30641 // MUST_USE_RES struct LDKRetryAttempts RetryAttempts_new(uintptr_t a_arg);
30643 export function RetryAttempts_new(a_arg: number): number {
30644 if(!isWasmInitialized) {
30645 throw new Error("initializeWasm() must be awaited first!");
30647 const nativeResponseValue = wasm.TS_RetryAttempts_new(a_arg);
30648 return nativeResponseValue;
30650 // uintptr_t RetryAttempts_clone_ptr(LDKRetryAttempts *NONNULL_PTR arg);
30652 export function RetryAttempts_clone_ptr(arg: number): number {
30653 if(!isWasmInitialized) {
30654 throw new Error("initializeWasm() must be awaited first!");
30656 const nativeResponseValue = wasm.TS_RetryAttempts_clone_ptr(arg);
30657 return nativeResponseValue;
30659 // struct LDKRetryAttempts RetryAttempts_clone(const struct LDKRetryAttempts *NONNULL_PTR orig);
30661 export function RetryAttempts_clone(orig: number): number {
30662 if(!isWasmInitialized) {
30663 throw new Error("initializeWasm() must be awaited first!");
30665 const nativeResponseValue = wasm.TS_RetryAttempts_clone(orig);
30666 return nativeResponseValue;
30668 // bool RetryAttempts_eq(const struct LDKRetryAttempts *NONNULL_PTR a, const struct LDKRetryAttempts *NONNULL_PTR b);
30670 export function RetryAttempts_eq(a: number, b: number): boolean {
30671 if(!isWasmInitialized) {
30672 throw new Error("initializeWasm() must be awaited first!");
30674 const nativeResponseValue = wasm.TS_RetryAttempts_eq(a, b);
30675 return nativeResponseValue;
30677 // uint64_t RetryAttempts_hash(const struct LDKRetryAttempts *NONNULL_PTR o);
30679 export function RetryAttempts_hash(o: number): bigint {
30680 if(!isWasmInitialized) {
30681 throw new Error("initializeWasm() must be awaited first!");
30683 const nativeResponseValue = wasm.TS_RetryAttempts_hash(o);
30684 return nativeResponseValue;
30686 // void PaymentError_free(struct LDKPaymentError this_ptr);
30688 export function PaymentError_free(this_ptr: number): void {
30689 if(!isWasmInitialized) {
30690 throw new Error("initializeWasm() must be awaited first!");
30692 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
30693 // debug statements here
30695 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
30697 export function PaymentError_clone_ptr(arg: number): number {
30698 if(!isWasmInitialized) {
30699 throw new Error("initializeWasm() must be awaited first!");
30701 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
30702 return nativeResponseValue;
30704 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
30706 export function PaymentError_clone(orig: number): number {
30707 if(!isWasmInitialized) {
30708 throw new Error("initializeWasm() must be awaited first!");
30710 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
30711 return nativeResponseValue;
30713 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
30715 export function PaymentError_invoice(a: number): number {
30716 if(!isWasmInitialized) {
30717 throw new Error("initializeWasm() must be awaited first!");
30719 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
30720 return nativeResponseValue;
30722 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
30724 export function PaymentError_routing(a: number): number {
30725 if(!isWasmInitialized) {
30726 throw new Error("initializeWasm() must be awaited first!");
30728 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
30729 return nativeResponseValue;
30731 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
30733 export function PaymentError_sending(a: number): number {
30734 if(!isWasmInitialized) {
30735 throw new Error("initializeWasm() must be awaited first!");
30737 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
30738 return nativeResponseValue;
30740 // 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 LDKRetryAttempts retry_attempts);
30742 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry_attempts: number): number {
30743 if(!isWasmInitialized) {
30744 throw new Error("initializeWasm() must be awaited first!");
30746 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry_attempts);
30747 return nativeResponseValue;
30749 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
30751 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
30752 if(!isWasmInitialized) {
30753 throw new Error("initializeWasm() must be awaited first!");
30755 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
30756 return nativeResponseValue;
30758 // 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);
30760 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
30761 if(!isWasmInitialized) {
30762 throw new Error("initializeWasm() must be awaited first!");
30764 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
30765 return nativeResponseValue;
30767 // 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);
30769 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
30770 if(!isWasmInitialized) {
30771 throw new Error("initializeWasm() must be awaited first!");
30773 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
30774 return nativeResponseValue;
30776 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
30778 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
30779 if(!isWasmInitialized) {
30780 throw new Error("initializeWasm() must be awaited first!");
30782 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
30783 // debug statements here
30785 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
30787 export function InvoicePayer_as_EventHandler(this_arg: number): number {
30788 if(!isWasmInitialized) {
30789 throw new Error("initializeWasm() must be awaited first!");
30791 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
30792 return nativeResponseValue;
30794 // 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);
30796 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): number {
30797 if(!isWasmInitialized) {
30798 throw new Error("initializeWasm() must be awaited first!");
30800 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);
30801 return nativeResponseValue;
30803 // 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);
30805 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): number {
30806 if(!isWasmInitialized) {
30807 throw new Error("initializeWasm() must be awaited first!");
30809 const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, keys_manager, network, amt_msat, description, duration_since_epoch);
30810 return nativeResponseValue;
30812 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
30814 export function DefaultRouter_free(this_obj: number): void {
30815 if(!isWasmInitialized) {
30816 throw new Error("initializeWasm() must be awaited first!");
30818 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
30819 // debug statements here
30821 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
30823 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
30824 if(!isWasmInitialized) {
30825 throw new Error("initializeWasm() must be awaited first!");
30827 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
30828 return nativeResponseValue;
30830 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
30832 export function DefaultRouter_as_Router(this_arg: number): number {
30833 if(!isWasmInitialized) {
30834 throw new Error("initializeWasm() must be awaited first!");
30836 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
30837 return nativeResponseValue;
30839 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
30841 export function ChannelManager_as_Payer(this_arg: number): number {
30842 if(!isWasmInitialized) {
30843 throw new Error("initializeWasm() must be awaited first!");
30845 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
30846 return nativeResponseValue;
30848 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
30850 export function SiPrefix_from_str(s: number): number {
30851 if(!isWasmInitialized) {
30852 throw new Error("initializeWasm() must be awaited first!");
30854 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
30855 return nativeResponseValue;
30857 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
30859 export function Invoice_from_str(s: number): number {
30860 if(!isWasmInitialized) {
30861 throw new Error("initializeWasm() must be awaited first!");
30863 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
30864 return nativeResponseValue;
30866 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
30868 export function SignedRawInvoice_from_str(s: number): number {
30869 if(!isWasmInitialized) {
30870 throw new Error("initializeWasm() must be awaited first!");
30872 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
30873 return nativeResponseValue;
30875 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
30877 export function ParseError_to_str(o: number): number {
30878 if(!isWasmInitialized) {
30879 throw new Error("initializeWasm() must be awaited first!");
30881 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
30882 return nativeResponseValue;
30884 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
30886 export function ParseOrSemanticError_to_str(o: number): number {
30887 if(!isWasmInitialized) {
30888 throw new Error("initializeWasm() must be awaited first!");
30890 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
30891 return nativeResponseValue;
30893 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
30895 export function Invoice_to_str(o: number): number {
30896 if(!isWasmInitialized) {
30897 throw new Error("initializeWasm() must be awaited first!");
30899 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
30900 return nativeResponseValue;
30902 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
30904 export function SignedRawInvoice_to_str(o: number): number {
30905 if(!isWasmInitialized) {
30906 throw new Error("initializeWasm() must be awaited first!");
30908 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
30909 return nativeResponseValue;
30911 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
30913 export function Currency_to_str(o: number): number {
30914 if(!isWasmInitialized) {
30915 throw new Error("initializeWasm() must be awaited first!");
30917 const nativeResponseValue = wasm.TS_Currency_to_str(o);
30918 return nativeResponseValue;
30920 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
30922 export function SiPrefix_to_str(o: number): number {
30923 if(!isWasmInitialized) {
30924 throw new Error("initializeWasm() must be awaited first!");
30926 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
30927 return nativeResponseValue;
30931 js_invoke = function(obj_ptr: number, fn_id: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number, arg7: number, arg8: number, arg9: number, arg10: number) {
30932 const weak: WeakRef<object> = js_objs[obj_ptr];
30933 if (weak == null || weak == undefined) {
30934 console.error("Got function call on unknown/free'd JS object!");
30935 throw new Error("Got function call on unknown/free'd JS object!");
30937 const obj: object = weak.deref();
30938 if (obj == null || obj == undefined) {
30939 console.error("Got function call on GC'd JS object!");
30940 throw new Error("Got function call on GC'd JS object!");
30944 case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
30945 case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
30946 case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
30947 case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
30948 case 4: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
30949 case 5: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
30950 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
30951 case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
30952 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
30953 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
30954 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
30955 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
30956 case 12: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
30957 case 13: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30958 case 14: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
30959 case 15: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
30960 case 16: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
30961 case 17: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
30962 case 18: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
30963 case 19: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
30964 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
30965 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
30966 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
30967 case 23: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
30968 case 24: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
30969 case 25: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
30970 case 26: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
30971 case 27: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
30972 case 28: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
30973 case 29: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
30974 case 30: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
30975 case 31: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
30976 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
30977 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
30978 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
30979 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
30980 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
30981 case 37: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
30982 case 38: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
30983 case 39: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
30984 case 40: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
30985 case 41: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
30986 case 42: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
30987 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
30988 case 44: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
30989 case 45: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
30990 case 46: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
30991 case 47: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
30992 case 48: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
30993 case 49: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_locked"); break;
30994 case 50: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
30995 case 51: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
30996 case 52: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
30997 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
30998 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
30999 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
31000 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
31001 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
31002 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
31003 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
31004 case 60: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
31005 case 61: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
31006 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
31007 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
31008 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
31009 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
31010 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
31011 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
31012 case 68: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
31013 case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
31014 case 70: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
31015 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
31016 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
31017 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
31018 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
31019 case 75: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
31020 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
31021 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
31022 case 78: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
31023 case 79: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
31024 case 80: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
31025 case 81: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
31026 case 82: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
31027 case 83: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
31028 case 84: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
31029 case 85: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
31030 case 86: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
31031 case 87: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
31032 case 88: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
31033 case 89: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
31034 case 90: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
31035 case 91: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
31036 case 92: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
31037 case 93: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
31039 console.error("Got unknown function call from C!");
31040 throw new Error("Got unknown function call from C!");
31042 if (fn == null || fn == undefined) {
31043 console.error("Got function call on incorrect JS object!");
31044 throw new Error("Got function call on incorrect JS object!");
31046 return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);